teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,231 @@
+def OneHotEncodingFit(data=None, category_data=None, target_column=None,
+                      attribute_column=None, value_column=None, is_input_dense=None,
+                      approach="LIST", categorical_values=None, target_column_names=None,
+                      categories_column=None, other_column="other", category_counts=None,
+                      target_attributes=None, other_attributes=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The OneHotEncodingFit() function outputs a DataFrame of attributes and categorical
+        values to input to OneHotEncodingTransform() function, which encodes them as
+        one-hot numeric vectors.
+        Notes:
+            * This function requires the UTF8 client character set for UNICODE data.
+            * This function does not support Pass Through Characters (PTCs).
+            * This function does not support KanjiSJIS or Graphic data types.
+            * For input to be considered as sparse input, column names should be
+              provided for 'data_partition_column' argument.
+            * In case of dense input, only allowed value for 'data_partition_column'
+              is PartitionKind.ANY and that for 'category_data_partition_column' is
+              PartitionKind.DIMENSION.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        category_data:
+            Optional Argument.
+            Specifies the data containing the input categories for 'LIST' approach.
+            Types: teradataml DataFrame
+
+        target_column:
+            Required when "is_input_dense" is set to 'True', disallowed otherwise.
+            Specifies the name of the column in "data" to be encoded.
+            Note:
+                * The maximum number of unique columns in the "target_column"
+                  argument is 2018.
+            Types: str OR list of Strings (str)
+
+        attribute_column:
+            Required when "is_input_dense" is set to 'False', disallowed otherwise.
+            Specifies the name of the column in "data" which contains attribute
+            names.
+            Types: str
+
+        value_column:
+            Required when "is_input_dense" is set to 'False', disallowed otherwise.
+            Specifies the name of the column in "data" which contains attribute
+            values.
+            Types: str
+
+        is_input_dense:
+            Required Argument.
+            Specifies whether input is in dense format or sparse format.
+            Note:
+                "category_data" is meant for dense input format and not for sparse format.
+            Types: bool
+
+        approach:
+            Optional Argument.
+            Specifies whether to determine categories automatically from the
+            input data (AUTO approach) or the user provided list (LIST approach).
+            Default Value: "LIST"
+            Permitted Values: AUTO, LIST
+            Types: str
+
+        categorical_values:
+            Required when "approach" is set to 'LIST' and a single value
+            is present in "target_column", optional otherwise.
+            Specifies the list of categories that need to be encoded in
+            the desired order.
+            When only one target column is provided, category values are read
+            from this argument. Otherwise, they will be read from the
+            "category_data".
+            Notes:
+                * The number of characters in "target_column_names" plus the
+                  number of characters in the category specified in the
+                  "categorical_values" argument must be less than 128 characters.
+                * The maximum number of categories in the "categorical_values"
+                  argument is 2018.
+            Types: str OR list of Strings (str)
+
+        target_column_names:
+            Required when "category_data" is used, optional otherwise.
+            Specifies the "category_data" column which contains the
+            names of the target columns.
+            Types: str
+
+        categories_column:
+            Required when "category_data" is used, optional otherwise.
+            Specifies the "category_data" column which contains the
+            category values.
+            Types: str
+
+        other_column:
+            Optional when "is_input_dense" is set to 'True', disallowed otherwise.
+            Specifies the column name for the column representing one-hot encoding
+            for values other than the ones specified in the "categorical_values"
+            argument or "category_data" or categories found through the 'auto'
+            approach.
+            Default Value: 'other'
+            Types: str
+
+        category_counts:
+            Required when "category_data" is used or "approach" is
+            set to 'auto', optional otherwise.
+            Specifies the category counts for each of the "target_column".
+            The number of values in "category_counts" should be the same
+            as the number of "target_column".
+            Types: str OR list of Strings (str)
+
+        target_attributes:
+            Required when "is_input_dense" is set to 'False', disallowed otherwise.
+            Specifies one or more attributes to encode in one-hot form. Every target attribute must
+            be in "attribute_column".
+            Types: str OR list of Strings (str)
+
+        other_attributes:
+            Optional when "is_input_dense" is set to 'False', disallowed otherwise.
+            For each target attribute, specifies a category name for attributes that "target_attributes"
+            does not specify. The nth "other_attributes" corresponds to the nth "target_attribute".
+            Notes:
+                * The number of characters in values specified in the "target_attributes" argument
+                  plus the number of characters in values specified in the "other_attributes"
+                  argument must be less than 128 characters.
+                * The number of values passed to the "target_attributes" argument and "other_attributes"
+                  argument must be equal.
+            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 OneHotEncodingFit.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as OneHotEncodingFitObj.<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", "cat_table"])
+
+        # Create teradataml DataFrame object.
+        titanic_data = DataFrame.from_table("titanic")
+        cat_data = DataFrame.from_table("cat_table")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Generate fit object to encode 'male' and 'female' values of column 'sex'.
+        fit_obj1 = OneHotEncodingFit(data=titanic_data,
+                                     is_input_dense=True,
+                                     target_column="sex",
+                                     categorical_values=["male", "female"],
+                                     other_column="other")
+
+        # Print the result DataFrame.
+        print(fit_obj1.result)
+
+        # Example 2: Generate fit object to encode column 'sex' and 'embarked' in dataset.
+        fit_obj2 = OneHotEncodingFit(data=titanic_data,
+                                     is_input_dense=True,
+                                     approach="auto",
+                                     target_column=["sex", "embarked"],
+                                     category_counts=[2, 3],
+                                     other_column="other")
+        # Print the result DataFrame.
+        print(fit_obj2.result)
+
+        # Example 3: Generate fit object when "category_data" is used.
+        fit_obj3 = OneHotEncodingFit(data=titanic_data,
+                                     category_data=cat_data,
+                                     target_column_names="column_name",
+                                     categories_column="category",
+                                     is_input_dense=True,
+                                     target_column=["sex", "embarked", "name"],
+                                     category_counts=[2, 4, 6],
+                                     other_column="other")
+        # Print the result DataFrame.
+        print(fit_obj3.result)
+
+        # Example 4: Generate fit object when "approach" is set to 'LIST'.
+        fit_obj4 = OneHotEncodingFit(data=titanic_data,
+                                     is_input_dense=True,
+                                     approach="list",
+                                     categorical_values=['male','female'],
+                                     target_column=["sex"],
+                                     other_column="other")
+        # Print the result DataFrame.
+        print(fit_obj4.result)
+    """

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

@@ -0,0 +1,121 @@
+def OneHotEncodingTransform(data=None, object=None, is_input_dense=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        Function encodes specified attributes and categorical values as one-hot numeric vectors,
+        using OneHotEncodingFit() function output.
+        Notes:
+            * In case of sparse input, neither 'data_partition_column' nor
+              'object_partition_column' can be used independently.
+            * In case of dense input, if 'data_partition_column' is having value
+              PartitionKind.ANY, then 'object_partition_column' should have value
+              PartitionKind.DIMENSION.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the encoding parameters generated by
+            OneHotEncodingFit() function or the instance of OneHotEncodingFit.
+            Types: teradataml DataFrame or OneHotEncodingFit
+
+        is_input_dense:
+            Required Argument.
+            Specifies whether input is in dense format or sparse format.
+            Types: boolean
+
+        **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 OneHotEncodingTransform.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as OneHotEncodingTransformObj.<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: Transform categorical column "sex" to numerical columns "sex_male", "sex_female",
+        #            and "sex_other" using OneHotEncodingFit() and OneHotEncodingTransform().
+
+        # Generate fit object for column "sex".
+        fit_obj = OneHotEncodingFit(data=titanic_data,
+                                    is_input_dense=True,
+                                    target_column="sex",
+                                    categorical_values=["male", "female"],
+                                    other_column="other")
+
+        # Print the result DataFrame.
+        print(fit_obj.result)
+
+        # Encode "male" and "female" values of column "sex".
+        # Note that teradataml DataFrame representing the model is passed as
+        # input to "object".
+        obj = OneHotEncodingTransform(data=titanic_data,
+                                      object=fit_obj.result,
+                                      is_input_dense=True)
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+        # Example 2: Encode "male" and "female" values of column "sex".
+        #            Note that model is passed as instance of OneHotEncodingFit
+        #            to "object".
+        obj1 = OneHotEncodingTransform(data=titanic_data,
+                                       object=fit_obj,
+                                       is_input_dense=True)
+
+        # Print the result DataFrame.
+        print(obj1.result)
+    """

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

@@ -0,0 +1,220 @@
+def OrdinalEncodingFit(data=None, category_data=None, target_column=None,
+                       approach="AUTO", categories=None, ordinal_values=None,
+                       target_column_names=None, categories_column=None,
+                       ordinal_values_column=None, start_value=0, default_value=None,
+                       **generic_arguments):
+    """
+    DESCRIPTION:
+        OrdinalEncodingFit() function identifies distinct categorical
+        values from the input data or a user-defined list and generates
+        the distinct categorical values along with the ordinal value for
+        each category.
+
+        Notes:
+            * Function requires the UTF8 client character set for UNICODE data.
+            * Function does not support Pass Through Characters (PTCs).
+            * Function does not support KanjiSJIS or Graphic data types.
+            * The maximum number of unique categories in a particular column is 4000.
+            * The maximum category length is 128 characters.
+            * NULL categories are not encoded.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input data containing the categorical target column.
+            Types: teradataml DataFrame
+
+        category_data:
+            Optional Argument.
+            Specifies the data containing the input categories for 'LIST' approach.
+            Types: teradataml DataFrame
+
+        target_column:
+            Required Argument.
+            Specifies the name of the categorical input target column.
+            Note:
+                The maximum number of unique columns in the "target_column" argument is 2018.
+            Types: str OR list of Strings (str)
+
+        approach:
+            Optional Argument.
+            Specifies whether to determine categories automatically from the
+            input data (AUTO approach) or determine categories from the list
+            provided by user (LIST approach).
+            Default Value: "AUTO"
+            Permitted Values: AUTO, LIST
+            Types: str
+
+        categories:
+            Optional Argument.
+            Specifies the list of categories that need to be encoded in the
+            desired order.
+            Notes:
+                * If only one target column is provided, category values
+                  read from this argument. Otherwise, they read from the
+                  "category_data".
+                * Required, when user use the 'LIST' approach and a single
+                  target column.
+            Types: str OR list of strs
+
+        ordinal_values:
+            Optional Argument.
+            Specifies the custom ordinal values to replace the categories,
+            when user use the 'LIST' approach for encoding the categorical values.
+            If user does not provide the "ordinal_values" and the "start_value",
+            then by default, the first category contains the default start value
+            '0', and the last category is assigned a value that is one lesser than
+            the total number of categories.
+            For example, if there are three categories, then the categories contain
+            the values 0, 1, 2 respectively.
+
+            However, if user only specify the ordinal values, then each ordinal value
+            is associated with a categorical value. For example, if there are three categories
+            and the ordinal values are 3, 4, 5 then the ordinal values are assigned to the
+            respective categories.
+            The OrdinalEncodingFit() function returns an error when the ordinal value
+            count does not match the categorical value count or if both the ordinal
+            values and the start value are provided.
+            Notes:
+                * User can either use the "ordinal_values" or the "start_value" argument
+                  in the syntax.
+                * If only one target column is provided, ordinal values are read from this argument.
+                  Otherwise, they are read from the "category_data".
+                * If omitted, ordinal values are generated based on the "start_value" argument.
+            Types: int OR list of ints
+
+        target_column_names:
+            Required when "category_data" is used, optional otherwise.
+            Specifies the "category_data" column which contains the names of the
+            target columns.
+            Types: str
+
+        categories_column:
+            Required when "category_data" is used, optional otherwise.
+            Specifies the "category_data" column which contains the category values.
+            Types: str
+
+        ordinal_values_column:
+            Required when "category_data" is used, optional otherwise.
+            Specifies the "category_data" column which contains the ordinal values.
+            If omitted, ordinal values will be generated based on the "start_value"
+            argument.
+            Types: str
+
+        start_value:
+            Optional Argument.
+            Specifies the starting value for ordinal values list.
+            Default Value: 0
+            Types: int
+
+        default_value:
+            Optional Argument.
+            Specifies the ordinal value to use when category is not found.
+            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 OrdinalEncodingFit.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as OrdinalEncodingFitObj.<attribute_name>.
+        Output teradataml DataFrame attribute names are:
+            1. result
+            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","cat_table"])
+
+        # Create teradataml DataFrame objects.
+        titanic = DataFrame.from_table("titanic")
+        cat_data = DataFrame.from_table("cat_table")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Identyfying distinct categorical values from the input.
+        ordinal_encodingfit_res_1 = OrdinalEncodingFit(target_column='sex',
+                                                       data=titanic)
+
+        # Print the result DataFrame.
+        print(ordinal_encodingfit_res_1.result)
+
+        # Example 2: Identifying distinct categorical values from the input and
+        #            returns the distinct categorical values along with the ordinal
+        #            value for each category.
+        ordinal_encodingfit_res_2 = OrdinalEncodingFit(target_column='sex',
+                                                       approach='LIST',
+                                                       categories=['category0', 'category1'],
+                                                       ordinal_values=[1, 2],
+                                                       start_value=0,
+                                                       default_value=-1,
+                                                       data=titanic)
+
+        # Print the result DataFrame.
+        print(ordinal_encodingfit_res_2.result)
+
+        # Example 3: Provide ordinal values to "target_column" using
+        #            dataset by "category_data".
+        ordinal_encodingfit_res_3 = OrdinalEncodingFit(target_column=['name','sex','ticket','cabin','embarked'],
+                                                       category_data=cat_data,
+                                                       approach='LIST',
+                                                       target_column_names="column_name",
+                                                       categories_column="category",
+                                                       ordinal_values_column="ordinal_value",
+                                                       default_value=[-1, -10, -15, 20, 0],
+                                                       data=titanic)
+
+        # Print the result DataFrame.
+        print(ordinal_encodingfit_res_3.result)
+
+        """