teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,105 @@
+def QQNorm(data=None, target_columns=None, rank_columns=None, output_columns=None, accumulate=None,
+           **generic_arguments):
+    """
+    DESCRIPTION:
+        Function determines if values in input data columns follow normal distribution or not. 
+        It returns the quantiles of the column values and corresponding theoretical quantile
+        values from a normal distribution. If the column values are normally distributed, then
+        the quantiles of column values and normal quantile values appear in a straight line
+        when plotted on a 2D graph.
+
+
+    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" to generate standard normal quantiles.
+            Types: str OR list of Strings (str)
+
+        rank_columns:
+            Required Argument.
+            Specifies the name(s) of the column(s) in "data" containing rank values for "target_columns".
+            Types: str OR list of Strings (str)
+
+        output_columns:
+            Optional Argument.
+            Specifies the name(s) of the output column(s) to be generated that contain the theoretical
+            quantiles of the target column(s). If not specified, name(s) will be generated as
+            "<column name in target_columns>_theoretical_quantiles".
+            Types: str OR list of strs
+
+        accumulate:
+            Optional Argument.
+            Specifies the names of input teradataml DataFrame columns to copy 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 table or not.
+                    When set to True, results are persisted in 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 volatile table or not.
+                    When set to True, results are stored in 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 Engine function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of QQNorm.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as QQNormObj.<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 sample rank_df DataFrame.
+        load_example_data("teradataml", ["rank_table"])
+
+        # Create teradataml DataFrame object.
+        rank_df = DataFrame.from_table("rank_table")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Get theoretical quantile values for 'age' and 'fare'.
+        obj = QQNorm(data=rank_df,
+                     target_columns=["age", "fare"],
+                     rank_columns=["rank_age", "rank_fare"])
+
+        # Print the result DataFrame.
+        print(obj.result)
+    """

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

@@ -0,0 +1,110 @@
+def RoundColumns(data=None, target_columns=None, precision_digit=0, accumulate=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        Function to round the values of each specified input DataFrame column to a
+        specified number of decimal places.
+
+
+    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" to round every value to
+            precision digits.
+            Types: str OR list of Strings (str)
+
+        precision_digit:
+            Optional Argument.
+            Specifies the number of decimal places to which to round values for
+            the "target_columns".
+            If positive, the function rounds values to the right of the decimal point.
+            If negative, the function rounds values to the left of the decimal point.
+            If not provided, the function rounds the column values to 0 places.
+            Note:
+                If the column values have the DECIMAL/NUMERIC data type with a precision less
+                than 38, then the function increases the precision by 1. For example, when a
+                DECIMAL (4,2) value of 99.99 is rounded to 0 places, the function returns a
+                DECIMAL (5,2) value, 100.00. However, if the precision is 38, then the function
+                only reduces the scale value by 1 unless the scale is 0. For example, the
+                function returns a DECIMAL (38, 36) value of 99.999999999 as a DECIMAL
+                (38, 35) value, 100.00.
+            Default Value: 0
+            Types: int
+
+        accumulate:
+            Optional Argument.
+            Specifies the names of input teradataml DataFrame columns to copy 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 table or not.
+                    When set to True, results are persisted in 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 volatile table or not.
+                    When set to True, results are stored in 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 Engine function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of RoundColumns.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as RoundColumnsObj.<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 1: Rounding "fare" column to 2 decimal places.
+        obj = RoundColumns(data=titanic_data,
+                           target_columns="fare",
+                           precision_digit=2,
+                           accumulate=['pclass', 'sex'])
+
+        # Print the result DataFrame.
+        print(obj.result)
+    """

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

@@ -0,0 +1,118 @@
+def RowNormalizeFit(data=None, target_columns=None, approach="UNITVECTOR", base_column=None,
+                    base_value=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        RowNormalizeFit() function outputs a DataFrame containing parameters and specified input columns
+        to input to RowNormalizeTransform() function, which normalizes the input columns row-wise.
+
+        
+    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" to normalize.
+            Types: str OR list of Strings (str)
+            
+        approach:
+            Optional Argument.
+            Specifies the method to use for row wise normalization.
+            Permitted Values:
+                * UNITVECTOR - X' = X / (sqrt (Σ\u1D62ϵ\u208D\u2081, \u2099\u208E X\u1D62\u00B2))
+                * FRACTION - X' = X / (Σ\u1D62ϵ\u208D\u2081, \u2099\u208E X\u1D62)
+                * PERCENTAGE - X' = X*100 / (Σ\u1D62ϵ\u208D\u2081, \u2099\u208E X\u1D62)
+                * INDEX - X' = V + ((X - B) / B) * 100
+                In the normalizing formulas:
+                    X' is the normalized value.
+                    X is the original value.
+                    B is the value in the base column.
+                    V is the base value.
+            Default Value: "UNITVECTOR"
+            Types: str
+            
+        base_column:
+            Required when "approach" is set to 'INDEX', ignored otherwise.
+            Specifies the base column to be used in INDEX "approach" formula.
+            Types: str
+            
+        base_value:
+            Required when "approach" is set to 'INDEX', ignored otherwise.
+            Specifies the base value to be used in INDEX "approach" formula.
+            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 table or not.
+                    When set to True, results are persisted in 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 volatile table or not.
+                    When set to True, results are stored in 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 Engine function supports, else an exception is raised.
+
+        
+    RETURNS:
+        Instance of RowNormalizeFit.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as RowNormalizeFitObj.<attribute_name>.
+        Output teradataml DataFrame attribute name 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", ["numerics"])
+
+        # Create teradataml DataFrame object.
+        numerics = DataFrame.from_table("numerics")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Create fit object to normalize ""smallint_col" and "integer_col"
+        #            columns using "INDEX" approach, "integer_col" as base column
+        #            and base value as 100.0.
+        fit_obj = RowNormalizeFit(data=numerics,
+                                  target_columns=["integer_col", "smallint_col"],
+                                  approach="INDEX",
+                                  base_column="integer_col",
+                                  base_value=100.0)
+
+        # Print the result DataFrame.
+        print(fit_obj.output)
+        print(fit_obj.output_data)
+"""

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

@@ -0,0 +1,99 @@
+def RowNormalizeTransform(data=None, object=None, accumulate=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        RowNormalizeTransform() function normalizes input columns row-wise, using
+        RowNormalizeFit() function output.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the output generated by
+            RowNormalizeFit() function or the instance of RowNormalizeFit.
+            Types: teradataml DataFrame or RowNormalizeFit
+
+        accumulate:
+            Optional Argument.
+            Specifies the names of input teradataml DataFrame columns to copy 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 table or not.
+                    When set to True, results are persisted in 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 volatile table or not.
+                    When set to True, results are stored in 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 Engine function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of RowNormalizeTransform.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as RowNormalizeTransformObj.<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", ["numerics"])
+
+        # Create teradataml DataFrame.
+        numerics = DataFrame.from_table("numerics")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Normalize "smallint_col" and "integer_col" columns using "INDEX"
+        #            approach, "integer_col" as base column and base value as 100.
+        fit_obj = RowNormalizeFit(data=numerics,
+                                  target_columns=["integer_col", "smallint_col"],
+                                  approach="INDEX",
+                                  base_column="integer_col",
+                                  base_value=100.0)
+
+        # Print the result DataFrame.
+        print(fit_obj.output)
+        print(fit_obj.output_data)
+
+        # Normalize the columns and accumulate the result by "id_col" column.
+        obj = RowNormalizeTransform(data=numerics,
+                                    object=fit_obj.output,
+                                    accumulate="id_col")
+
+        # Print the result DataFrame.
+        print(obj.result)
+    """

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

@@ -0,0 +1,153 @@
+def SVMSparsePredict(object=None, newdata=None, sample_id_column=None, attribute_column=None, value_column=None,
+                     accumulate_label=None, output_class_num=1, output_prob = True, output_responses = None,
+                     **generic_arguments):
+    """
+    DESCRIPTION:
+    The SVMSparsePredict() function takes the model generated by the
+    SVMSparse() trainer function and a set of test samples (in sparse
+    format) and outputs a prediction for each sample.
+
+
+    PARAMETERS:
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the model data
+            generated by SVMSparse() function or instance of SVMSparse.
+            Types: teradataml DataFrame or SVMSparse
+
+        newdata:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the input test data.
+            Types: teradataml DataFrame
+
+        sample_id_column:
+            Required Argument.
+            Specifies the name of the newdata column that contains the
+            identifiers of the test samples. The newdata table must be
+            partitioned by this column.
+            Types: str
+
+        attribute_column:
+            Required Argument.
+            Specifies the name of the newdata column that contains the
+            attributes of the test samples.
+            Types: str
+
+        value_column:
+            Optional Argument.
+            Specifies the name of the newdata column that contains the
+            attribute values. By default, each attribute has the value 1.
+            Types: str
+
+        accumulate_label:
+            Optional Argument.
+            Specifies the names of the newdata columns to copy to the
+            output teradataml DataFrame.
+            Types: str OR list of Strings (str)
+
+        output_class_num:
+            Optional Argument.
+            Specifies the number of class labels to appear in the output
+            teradataml DataFrame, with its corresponding prediction confidence.
+            Valid only for multiple-class models.
+            Default Value: 1
+            Types: int
+
+        output_prob:
+            Optional Argument.
+            Specifies whether to display output probability for the predicted
+            category.
+            Default Value: True
+            Types: bool
+
+        output_responses:
+            Optional Argument.
+            Specifies responses for which to output probabilities.
+            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 table or not.
+                    When set to True, results are persisted in 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 volatile table or not.
+                    When set to True, results are stored in 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 Engine
+                function supports, else an exception is raised.
+
+
+    RETURNS:
+        Instance of SVMSparsePredict.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as SVMSparsePredictObj.<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("SVMSparsePredict",["svm_iris_input_test"])
+        load_example_data("teradataml", "svm_iris_model")
+
+        # Create teradataml DataFrame
+        svm_train = DataFrame.from_table("svm_iris_model")
+        svm_iris_input_test = DataFrame.from_table("svm_iris_input_test")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: teradataml DataFrame containing the model data is passed as input
+        #            to object argument.
+        svm_sparse_predict_result1 = teradataml.SVMSparsePredict(newdata=svm_iris_input_test,
+                                                                 object=svm_train,
+                                                                 attribute_column='attribute',
+                                                                 sample_id_column='id',
+                                                                 value_column='value1',
+                                                                 accumulate_label='species')
+
+        # Print the result DataFrame
+        print(svm_sparse_predict_result1.result)
+
+        # Example 2: Predict the species and display probability for "setosa" and "virginica".
+        svm_sparse_predict_result2 = teradataml.SVMSparsePredict(newdata=svm_iris_input_test,
+                                                                 object=svm_train,
+                                                                 attribute_column='attribute',
+                                                                 sample_id_column='id',
+                                                                 value_column='value1',
+                                                                 accumulate_label='species',
+                                                                 output_prob= True,
+                                                                 output_responses= ['setosa', 'virginica'])
+
+        # Print the result DataFrame.
+        print(svm_sparse_predict_result2.result)
+    """