teradataml 20.0.0.8__py3-none-any.whl

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

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

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

@@ -0,0 +1,112 @@
+def PolynomialFeaturesFit(data=None, target_columns=None, include_bias=True, interaction_only=False, degree=2,
+                          **generic_arguments):
+    """
+    DESCRIPTION:
+        PolynomialFeaturesFit() function stores all the specified values in the argument in a DataFrame format.
+        All polynomial combinations of the features with degrees less than or equal to the specified degree are
+        generated. For example, for a two-dimensional input sample [x, y], the degree-2 polynomial features are
+        [x, y, x-squared, xy, y-squared, 1].
+
+
+    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 polynomial
+            features needs to be generated.
+            Types: str OR list of Strings (str)
+
+        include_bias:
+            Optional Argument.
+            Specifies whether to include bias column in the output or not.
+            A bias column acts as an intercept term in a linear model.
+            Default Value: True
+            Types: bool
+
+        interaction_only:
+            Optional Argument.
+            Specifies whether to output polynomial combinations only for interaction features
+            (features that are products of at most degree distinct input features).
+            Default Value: False
+            Types: bool
+
+        degree:
+            Optional Argument.
+            Specifies the maximum degree of the input features to output polynomial combinations.
+            Permitted Values: 1, 2, 3
+            Default Value: 2
+            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: 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 PolynomialFeaturesFit.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as PolynomialFeaturesFitObj.<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", ["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 create polynomial features for columns
+        #            "integer_col" and "smallint_col".
+        fit_obj = PolynomialFeaturesFit(data=numerics,
+                                        target_columns=["integer_col", "smallint_col"],
+                                        degree=2)
+
+        # Print the result DataFrame.
+        print(fit_obj.output)
+        print(fit_obj.output_data)
+    """

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

@@ -0,0 +1,112 @@
+def PolynomialFeaturesTransform(data=None, object=None, accumulate=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        PolynomialFeaturesTransform() function generates a feature matrix of all polynomial
+        combinations of the feature by extracting the target column, degree, bias and interaction
+        information from the output of the PolynomialFeaturesFit() function.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the output of generated by
+            PolynomialFeaturesFit() function or the instance of PolynomialFeaturesFit.
+            Types: teradataml DataFrame or PolynomialFeaturesFit
+
+        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 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 PolynomialFeaturesTransform.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as 
+        PolynomialFeaturesTransformObj.<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 object.
+        numerics = DataFrame.from_table("numerics")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Generate feature DataFrame for all 2D polynomial combination of columns
+        #            "integer_col"and "smallint_col".
+        fit_obj = PolynomialFeaturesFit(data=numerics,
+                                        target_columns=["integer_col", "smallint_col"],
+                                        degree=2)
+
+        # Print the result DataFrame.
+        print(fit_obj.output)
+        print(fit_obj.output_data)
+
+        # Generate feature matrix. Note that teradataml DataFrame representing
+        # the model is passed as input to "object".
+        obj = PolynomialFeaturesTransform(data=numerics,
+                                            object=fit_obj.output
+                                            )
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+        # Example 2: Generate feature matrix. Note that model is passed as instance of
+        #            PolynomialFeaturesFit to "object".
+        obj1 = PolynomialFeaturesTransform(data=numerics,
+                                           object=fit_obj
+                                           )
+
+        # Print the result DataFrame.
+        print(obj1.result)
+    """

teradataml/data/docs/sqle/docs_17_20/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 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 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)
+    """