teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,187 @@
+def StrApply(data=None, target_columns=None, output_columns=None, accumulate=None, string_operation=None, operating_side=None,
+             in_place=True, string=None, escape_string=None, is_case_specific=True, ignore_trailing_blank=False,
+             string_length=None, start_index=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        StrApply() function applies a specified string operator to the specified input DataFrame columns.
+
+
+    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 perform string operations on.
+            Types: str OR list of Strings (str)
+
+        output_columns:
+            Optional Argument.
+            Specifies the output column names that contains the output of the
+            string operation on the columns values.
+            Types: str OR list Strings (str)
+
+        accumulate:
+            Optional Argument.
+            Specifies the names of input teradataml DataFrame columns to copy to
+            the output.
+            Types: str OR list of Strings (str)
+
+        string_operation:
+            Required Argument.
+            Specifies the string method to use on the target columns.
+            Permitted Values:
+                * TOUPPER
+                * TOLOWER
+                * strTRIM
+                * strCON
+                * strPAD
+                * strLIKE
+                * strINDEX
+                * INITCAP
+                * TRIMSPACES
+                * CHARTOHEXINT
+                * strREVERSE
+                * SUBstr
+                * GETNCHARS
+                * UNICODEstr
+            Types: str
+
+        operating_side:
+            Optional Argument.
+            Specifies the operating side to consider while performing operations
+            like 'stringPad', 'getNchars'.
+            Permitted Values: LEFT, RIGHT
+            Default Value: LEFT
+            Types: str
+
+        in_place:
+            Optional Argument.
+            Specifies whether to use the same column name for the resulted target
+            columns.
+            Default Value: True
+            Types: bool
+
+        string:
+            Optional Argument.
+            Specifies the names of the strings to use as input while applying
+            string operation.
+            Types: str OR list of Strings (str)
+
+        escape_string:
+            Optional Argument.
+            Specifies the names of the string to use as an escape string while
+            applying stringLike operation.
+            Types: str OR list of Strings (str)
+
+        is_case_specific:
+            Optional Argument.
+            Specifies whether to consider uppercase letters(e.g. "A") and lowercase
+            letters(e.g. "a") as same or different.
+            Default Value: True
+            Types: bool
+
+        ignore_trailing_blank:
+            Optional Argument.
+            Specifies whether to ignore trailing blanks in the column strings. Used
+            if the stringOperation is 'StringLike' only.
+            Default Value: False
+            Types: bool
+
+        string_length:
+            Optional Argument.
+            Specifies the length of a string.
+            Types: int
+
+        start_index:
+            Optional Argument.
+            Specifies the start index of the target column string. Used only if
+            the string operation is 'SubString'.
+            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 it, else an exception is raised.
+
+    RETURNS:
+        Instance of StrApply.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as StrApplyObj.<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: Apply 'TOUPPER' string operator to the
+        #            specified input "name" columns.
+        obj = StrApply(data=titanic_data,
+                       target_columns='name',
+                       string_operation='TOUPPER',
+                       in_place=False)
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+        # Example 2: Apply StrApply using all the arguments.
+        obj = StrApply(data=titanic_data,
+                       data_partition_column='age',
+                       data_order_column='age',
+                       target_columns='name',
+                       accumulate='passenger',
+                       output_columns='str_op_output',
+                       string_operation='TOUPPER',
+                       in_place=False,
+                       persist=True)
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+    """

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

@@ -0,0 +1,146 @@
+def StringSimilarity(data=None, comparison_columns=None, case_sensitive=None, accumulate=None,
+                     **generic_arguments):
+    """
+    DESCRIPTION:
+        StringSimilarity() function calculates the similarity between two
+        strings, using either the Jaro, Jaro-Winkler, N-Gram, or Levenshtein
+        distance.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        comparison_columns:
+            Required Argument.
+            Specifies pairs of input teradataml DataFrame columns that contain
+            strings to be compared (column1 and column2), how to compare them
+            (comparison_type), and (optionally) a constant and the name of the
+            output column for their similarity (output_column). The similarity is
+            a value in the range [0, 1].
+            For comparison_type, use one of these values:
+                * "jaro": Jaro distance.
+                * "jaro_winkler": Jaro-Winkler distance (1 for an exact match, 0 otherwise).
+                  If you specify this comparison type, you can specify the value of
+                  factor p with constant. 0 ≤ p ≤ 0.25.
+                  Default: p = 0.1
+                * "n_gram": N-gram similarity.
+                  If you specify this comparison type, you can specify the value of N with
+                  constant.
+                  Default: N = 2
+                * "LD": Levenshtein distance
+                  The number of edits needed to transform one string into the other,
+                  where edits include insertions, deletions, or substitutions of
+                  individual characters.
+                * "LDWS": Levenshtein distance without substitution.
+                  Number of edits needed to transform one string into the other using only
+                  insertions or deletions of individual characters.
+                * "OSA": Optimal string alignment distance.
+                  Number of edits needed to transform one string into the other.
+                  Edits are insertions, deletions, substitutions, or transpositions of
+                  characters. A substring can be edited only once.
+                * "DL": Damerau-Levenshtein distance.
+                  Like OSA, except that a substring can be edited any number of times.
+                * "hamming": Hamming distance.
+                  Number of positions where corresponding characters differ (that is,
+                  minimum number of substitutions needed to transform one string into the
+                  other) for strings of equal length, otherwise -1 for strings of unequal
+                  length.
+                * "LCS": Longest common substring.
+                  Length of longest substring common to both strings.
+                * "jaccard": Jaccard index-based comparison.
+                * "cosine": Cosine similarity.
+                * "soundexcode": Only for English strings. -1 if either string has a
+                  non-English character, otherwise, 1 if their soundex codes are the same
+                  and 0 otherwise.
+            You can specify a different comparison_type for every pair of columns.
+            The default output_column is "sim_i", where i is the sequence number of the
+            column pair.
+            Types: str OR list of Strings (str)
+
+        case_sensitive:
+            Optional Argument.
+            Specifies whether string comparison is case-sensitive. The default
+            value is False. You can specify either one value for all pairs or
+            one value for each pair. If you specify one value for each pair, then
+            the ith value applies to the ith pair.
+            Types: bool OR list of bools
+
+        accumulate:
+            Optional Argument.
+            Specifies the names of input teradataml DataFrame columns to be
+            copied 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 StringSimilarity.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as StringSimilarityObj.<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("stringsimilarity", ["strsimilarity_input"])
+
+        # Create teradataml DataFrame object.
+        strsimilarity_input = DataFrame.from_table("strsimilarity_input")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Creating teradataml dataframe by calculating the
+        #            similarity between two strings.
+        obj = StringSimilarity(data = strsimilarity_input,
+                               comparison_columns=['jaro (src_text1, tar_text) AS jaro1_sim',
+                                                   'LD (src_text1, tar_text) AS ld1_sim',
+                                                   'n_gram (src_text1, tar_text, 2) AS ngram1_sim',
+                                                   'jaro_winkler (src_text1, tar_text, 0.1) AS jw1_sim'],
+                               case_sensitive = True,
+                               accumulate = ["id","src_text1","tar_text"])
+
+        # Print the result DataFrame.
+        print(obj.result)
+    """

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

@@ -0,0 +1,207 @@
+def TDDecisionForestPredict(newdata=None, object=None, id_column=None,
+                            detailed=False, output_prob=False, output_responses=None,
+                            accumulate=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        TDDecisionForestPredict() function uses the model output by DecisionForest()
+        function to analyze the input data and make predictions. This function outputs
+        the probability that each observation is in the predicted class.
+
+        Processing times are controlled by the number of trees in the model.
+        When the number of trees is more than what can fit in memory, then
+        the trees are cached in a local spool space.
+
+
+    PARAMETERS:
+        newdata:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the input data.
+            Types: teradataml DataFrame
+
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame which contains the model data generated by
+            the DecisionForest() function or instance of DecisionForest.
+            Types: teradataml DataFrame or DecisionForest
+
+        id_column:
+            Required Argument.
+            Specifies a column containing a unique identifier for each test point
+            in the test set.
+            Types: str
+
+        detailed:
+            Optional Argument.
+            Specifies whether to output detailed information about the decision
+            tree and the specific tree information, including task index and
+            tree index for each tree.
+            Default Value: False
+            Types: bool
+
+        output_prob:
+            Optional Argument.
+            Specifies whether to output probability for each response.
+            Notes:
+                * If "output_prob" is false the function outputs only
+                  the probability of the predicted class.
+                * The "output_prob" must be true when using "output_responses".
+                * The "output_prob" only works with a classification model.
+            Default Value: False
+            Types: bool
+
+        output_responses:
+            Optional Argument.
+            Specifies the classes to output the probabilities. By default it
+            output only the probability of the predicted class.
+            Note:
+                * The "output_responses" only works with a classification model.
+            Types: str OR list of str(s)
+
+        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: bool
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the
+                    function in a volatile table or not. When set to
+                    True, results are stored in a volatile table,
+                    otherwise not.
+                    Default Value: False
+                    Types: bool
+
+            Function allows the user to partition, hash, order or local
+            order the input data. These generic arguments are available
+            for each argument that accepts teradataml DataFrame as
+            input and can be accessed as:
+                * "<input_data_arg_name>_partition_column" accepts str or
+                    list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list
+                    of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list
+                    of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if
+                the underlying SQLE Engine function supports, else an
+                exception is raised.
+
+    RETURNS:
+        Instance of TDDecisionForestPredict.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as TDDecisionForestPredictObj.<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("decisionforest", ["boston"])
+        load_example_data("byom", "iris_input")
+
+        # Create teradataml DataFrame objects.
+        boston = DataFrame.from_table("boston")
+        iris_input = DataFrame("iris_input")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1 : This example takes boston data as input, and generates the Regression
+        #             model using DecisionForest(). Using TDDecisionForestPredict() function
+        #             to predict the medv with the Regression model generated by DecisionForest().
+
+        # Create 2 samples of input data - sample 1 will have 80% of total rows and
+        # sample 2 will have 20% of total rows.
+        boston_sample = boston.sample(frac=[0.8, 0.2])
+
+        # Create train dataset from sample 1 by filtering on "sampleid" and drop
+        # "sampleid" column as it is not required for training model.
+        boston_train = boston_sample[boston_sample.sampleid == "1"].drop("sampleid", axis = 1)
+
+        # Create test dataset from sample 2 by filtering on "sampleid" and
+        # drop "sampleid" column as it is not required for scoring.
+        boston_test = boston_sample[boston_sample.sampleid == "2"].drop("sampleid", axis = 1)
+
+        # Training the model.
+        DecisionForest_out = DecisionForest(data = boston_train,
+                                            input_columns = ['crim', 'zn', 'indus', 'chas', 'nox', 'rm',
+                                                            'age', 'dis', 'rad', 'tax', 'ptratio', 'black',
+                                                            'lstat'],
+                                            response_column = 'medv',
+                                            max_depth = 12,
+                                            num_trees = 4,
+                                            min_node_size = 1,
+                                            mtry = 3,
+                                            mtry_seed = 1,
+                                            seed = 1,
+                                            tree_type = 'REGRESSION')
+
+        # TDDecisionForestPredict() predicts the result using generated Regression model by
+        # DecisionForest() and "newdata".
+        TDDecisionForestPredict_out = TDDecisionForestPredict(newdata=boston_test,
+                                                              object=DecisionForest_out,
+                                                              id_column="id")
+
+        # Print the result DataFrame.
+        print(TDDecisionForestPredict_out.result)
+
+        # Example 2 : This example takes iris_input data, and generates the Classification
+        #             model using DecisionForest(). Using TDDecisionForestPredict() function
+        #             to predict the species with the Classification model generated by XGBoost().
+        #             Provides the classes for which to output the probabilities.
+
+        # Create 2 samples of input data - sample 1 will have 80% of total rows and
+        # sample 2 will have 20% of total rows.
+        iris_sample = iris_input.sample(frac=[0.8, 0.2])
+
+        # Create train dataset from sample 1 by filtering on "sampleid" and drop
+        # "sampleid" column as it is not required for training model.
+        iris_train = iris_sample[iris_sample.sampleid == "1"].drop("sampleid", axis = 1)
+
+        # Create test dataset from sample 2 by filtering on "sampleid" and
+        # drop "sampleid" column as it is not required for scoring.
+        iris_test = iris_sample[iris_sample.sampleid == "2"].drop("sampleid", axis = 1)
+
+        # Training the model.
+        DecisionForest_out_2 = DecisionForest(data=iris_train,
+                                              input_columns=['sepal_length', 'sepal_width', 'petal_length', 'petal_width'],
+                                              response_column="species",
+                                              tree_type="CLASSIFICATION")
+
+        # TDDecisionForestPredict() predicts the result using generated Regression model by
+        # DecisionForest() and "newdata".
+        TDDecisionForestPredict_out_2 = TDDecisionForestPredict(newdata=iris_test,
+                                                                object=DecisionForest_out_2,
+                                                                id_column="id",
+                                                                output_prob=True,
+                                                                output_responses=['1', '2', '3'])
+
+        # Print the result DataFrame.
+        print(TDDecisionForestPredict_out_2.result)
+    """