teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,172 @@
+def BincodeFit(data=None, fit_data=None, target_columns=None, method_type=None,
+               nbins=None, label_prefix=None, target_colnames=None,
+               minvalue_column=None, maxvalue_column=None, label_column=None,
+               **generic_arguments):
+    """
+    DESCRIPTION:
+        The BinCodeFit() function outputs a DataFrame of information to input to
+        BinCodeTransform() function, which bin-codes the specified input DataFrame.
+        Bin-coding is typically used to convert numeric data to categorical data by
+        binning the numeric data into multiple numeric bins (intervals).
+        The bins can have a fixed-width with auto-generated labels or can have variable
+        widths and labels.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        fit_data:
+            Optional Argument.
+            Specifies the input teradataml DataFrame containing binning parameters for
+            VARIABLE-WIDTH. It is not needed for EQUAL-WIDTH.
+            Types: teradataml DataFrame
+
+        target_columns:
+            Required Argument.
+            Specifies the input teradataml DataFrame columns to generate bins information
+            and binning parameters on.
+            Types: str OR list of Strings (str)
+
+        method_type:
+            Required Argument.
+            Specifies the Method Type which will be used for histogram computation.
+            Permitted Values: EQUAL-WIDTH, VARIABLE-WIDTH
+            Types: str
+
+        nbins:
+            Optional Argument.
+            Specifies the number of bins to be used when "method_type" is
+            EQUAL-WIDTH. It is not needed for VARIABLE-WIDTH. If one value is provided,
+            it applies to all target columns, if more than one value is
+            specified, "nbins" values apply to "target_columns" in the order
+            specified by the user.
+            Types: int OR list of ints
+
+        label_prefix:
+            Optional Argument.
+            Specify the label prefix to be used when MethodType is EQUAL-WIDTH. If
+            one value is provided, it applies to all target columns. If more than
+            one value is specified, "label_prefix" values apply to "target_columns"
+            in the order specified by the user.
+            Default Value:  target column names.
+            Types: str OR list of strs
+
+        target_colnames:
+            Optional Argument.
+            Specifies the "fit_data" column which contains column name for
+            which bins are specified.
+            Default Value: ColumnName.
+            Types: str
+
+        minvalue_column:
+            Optional Argument.
+            Specifies the "fit_data" column which contains Min Value for the
+            specified bins.
+            Default Value: MinValue.
+            Types: str
+
+        maxvalue_column:
+            Optional Argument.
+            Specifies the "fit_data" column which contains Max Value for the
+            specified bins.
+            Default Value: MaxValue.
+            Types: str
+
+        label_column:
+            Optional Argument.
+            Specifies the "fit_data" column which contains label for which
+            bins are specified.
+            Default Value: Label.
+            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 BincodeFit.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as BincodeFitObj.<attribute_name>.
+        Output teradataml DataFrame attribute names are:
+            1. output
+            2. output_data
+
+
+    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", ["titanic", "bin_fit_ip"])
+
+        # Create teradataml DataFrame objects.
+        titanic_data = DataFrame.from_table("titanic")
+        bin_fit_ip = DataFrame.from_table("bin_fit_ip")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Transform the data using BincodeFit object with Variable-Width.
+        bin_code_1 = BincodeFit(data=titanic_data,
+                                fit_data=bin_fit_ip,
+                                fit_data_order_column = ['minVal', 'maxVal'],
+                                target_columns='age',
+                                minvalue_column='minVal',
+                                maxvalue_column='maxVal',
+                                label_column='label',
+                                method_type='Variable-Width',
+                                label_prefix='label_prefix'
+                               )
+
+        # Print the result.
+        print(bin_code_1.output)
+
+        # Example 2: Transform the data using BincodeFit object with Equal-Width.
+        bin_code_2 = BincodeFit(data=titanic_data,
+                                target_columns='age',
+                                method_type='Equal-Width',
+                                nbins=2,
+                                label_prefix='label_prefix'
+                               )
+
+        # Print the result.
+        print(bin_code_2.output)
+
+    """

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

@@ -0,0 +1,139 @@
+def BincodeTransform(data=None, object=None, accumulate=None,
+                     **generic_arguments):
+    """
+    DESCRIPTION:
+        The BincodeTransform() function is used to convert the continuous numeric data to
+        categorical data. The BincodeTransform() function takes the output of BincodeFit()
+        function to apply the transform on input DataFrame.
+        BincodeTransform() function takes two DataFrames as input:
+            1. Input dataframe which contains numeric data to be converted to categorical
+               data.
+            2. Output of BincodeFit() function which contains the binning data.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the binning parameters
+            generated by BincodeFit() function or the instance of BincodeFit.
+            Types: teradataml DataFrame or BincodeFit
+
+        accumulate:
+            Optional Argument.
+            Specifies the name(s) of input teradataml DataFrame column(s) to copy to the
+            output. By default, the function copies no input teradataml
+            DataFrame columns to the output.
+            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 BincodeTransform.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as BincodeTransformObj.<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", ["titanic", "bin_fit_ip"])
+
+        # Create teradataml DataFrame objects.
+        titanic_data = DataFrame.from_table("titanic")
+        bin_fit_ip = DataFrame.from_table("bin_fit_ip")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Convert the continuous numeric data in the column 'age' to
+        #            categorical data.
+
+        # First generate a model using BinCodeFit() function to bin-code the values
+        # in column 'age' using the 'Variable-Width' method type.
+        bin_code_1 = BincodeFit(data=titanic_data,
+                                fit_data=bin_fit_ip,
+                                fit_data_order_column = ['minVal', 'maxVal'],
+                                target_columns='age',
+                                minvalue_column='minVal',
+                                maxvalue_column='maxVal',
+                                label_column='label',
+                                method_type='Variable-Width',
+                                label_prefix='label_prefix'
+                               )
+
+        # Apply the transformation on the input data using the model generated above.
+        # Note the model is passed as a teradataml DataFrame.
+        obj = BincodeTransform(data=titanic_data,
+                               object=bin_code_1.output,
+                               object_order_column="TD_MinValue_BINFIT",
+                               accumulate=['passenger', 'ticket']
+                               )
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+        # Example 2: Convert the continuous numeric data in the column 'age' to
+        #            categorical data.
+
+        # First generate a model using BinCodeFit() function to bin-code the values
+        # in column 'age' using the 'Equal-Width' method type.
+        bin_code_2 = BincodeFit(data=titanic_data,
+                                target_columns='age',
+                                method_type='Equal-Width',
+                                nbins=2,
+                                label_prefix='label_prefix'
+                                )
+
+        # Apply the transformation on the input data using the model generated above.
+        # Note that model is passed as instance of BincodeFit to "object".
+        obj = BincodeTransform(data=titanic_data,
+                               object=bin_code_2,
+                               accumulate=['passenger', 'ticket']
+                               )
+
+        # Print the result DataFrame.
+        print(obj.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/CategoricalSummary.py

@@ -0,0 +1,86 @@
+def CategoricalSummary(data = None, target_columns = None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The CategoricalSummary() function displays the distinct values and their counts for
+        each specified input DataFrame column.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        target_columns:
+            Required Argument.
+            Specifies the name(s) of the column(s) in "data" for which
+            categorical summary needs to be determined.
+            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 CategoricalSummary.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as CategoricalSummaryObj.<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", "titanic")
+
+        # Create teradataml DataFrame object.
+        titanic_data = DataFrame.from_table("titanic")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example: Find the distinct values and counts for column 'sex'.
+        obj = CategoricalSummary(data=titanic_data,
+                                 target_columns="sex"
+                                )
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+    """

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

@@ -0,0 +1,90 @@
+def ChiSq(data=None, alpha=0.05, **generic_arguments):
+    """
+    DESCRIPTION:
+        The ChiSq() function performs Pearson's chi-squared (χ2) test for independence,
+        which determines if there is a statistically significant difference between
+        the expected and observed frequencies in one or more categories of a
+        contingency table (also called a cross tabulation).
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        alpha:
+            Optional Argument.
+            Specifies the probability below which the null hypothesis is rejected.
+            "alpha" must be a numeric value in the range [0, 1].
+            Default Value: 0.05
+            Types: float
+
+        **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 ChiSq.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as ChiSq.<attribute_name>.
+        Output teradataml DataFrame attribute names are:
+            1. output_data
+            2. output
+
+    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", "chi_sq")
+
+        # Create teradataml DataFrame object.
+        chi_sq_data = DataFrame.from_table("chi_sq")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example: Run ChiSq() with all arguments.
+        obj = ChiSq(data=chi_sq_data,
+                    alpha=0.5)
+
+        # Print the output DataFrame and expected values DataFrame.
+        print(obj.output)
+        print(obj.output_data)
+
+    """