teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,215 @@
+def KNN(test_data = None, train_data = None, id_column = None, input_columns = None,
+        model_type = "classification", k = 5, accumulate = None,  response_column = None,
+        voting_weight = 0, tolerance = 1.0E-7, output_prob = False, output_responses = None,
+        emit_neighbors = None, emit_distances = False, **generic_arguments):
+    """
+    DESCRIPTION:
+        The KNN() function classifies data objects based on proximity to other 
+        data objects with known categories.
+    
+    
+    PARAMETERS:
+        test_data:
+            Required Argument.
+            Specifies the input teradataml DataFrame containing the test data.
+            Types: teradataml DataFrame
+        
+        train_data:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the train data.
+            Types: teradataml DataFrame
+        
+        id_column:
+            Required Argument.
+            Specifies the name of the column that uniquely identifies a data object 
+            both in train and test data.
+            Types: str
+        
+        input_columns:
+            Required Argument.
+            Specifies the name(s) of the column(s) in train data that the 
+            function uses to compute the distance between a test object and 
+            the train objects. The test data must also have these columns.
+            Types: str OR list of Strings (str)
+        
+        model_type:
+            Optional Argument.
+            Specifies the model type for KNN function.
+            Default Value: "classification"
+            Permitted Values: regression, classification, neighbors
+            Types: str
+        
+        k:
+            Optional Argument.
+            Specifies the number of nearest neighbors to use in the algorithm.
+            Any positive integer value > 0 and <= 1000 can be chosen.
+            Default Value: 5
+            Types: int
+        
+        accumulate:
+            Optional Argument.
+            Specifies the name(s) of the column(s) in test data
+            to be copied to output.
+            Types: str OR list of Strings (str)
+        
+        response_column:
+            Optional Argument. Required when model type is regression or classification.
+            Specifies the name of the train data column that contains the 
+            numeric response variable values to be used for prediction in KNN 
+            based regression or classification.
+            Types: str
+        
+        voting_weight:
+            Optional Argument.
+            Specifies the voting weight of the train object for determining 
+            the class of the test object as a function of the distance between 
+            the train and test objects. The voting weight is calculated as w, 
+            where w=1/POWER(distance, voting_weight) and distance is the distance 
+            between the test object and the train object. Must be a 
+            non-negative real number.
+            Default Value: 0
+            Types: float OR int
+        
+        tolerance:
+            Optional Argument.
+            Specifies the user to define the smallest distance to be considered. 
+            When a non-zero voting weight is used, the case of zero distance 
+            causes the weight (w=1/POWER(distance, voting_weight)) to be undefined.
+            For any distance under the given tolerance, the weight is calculated as 
+            w=1/POWER(tolerance, voting_weight).
+            Default Value: 1.0E-7
+            Types: float OR int
+        
+        output_prob:
+            Optional Argument.
+            Specifies whether the function should output the probability for each 
+            response specified in "response_column". If "response_column" is not given, 
+            outputs the probability of the predicted response.
+            Default Value: False
+            Types: bool
+        
+        output_responses:
+            Optional Argument.
+            Specifies the class labels for which to output probabilities.
+            Types: str OR list of strs
+        
+        emit_neighbors:
+            Optional Argument.
+            Specifies whether the neighbors are to be emitted in the output.
+            Default Value: False
+            Types: bool
+        
+        emit_distances:
+            Optional Argument.
+            Specifies whether the neighbor distances are to be emitted in the output.
+            Default Value: False
+            Types: bool
+        
+        **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 bool
+            Note:
+                These generic arguments are supported by teradataml if 
+                the underlying SQL Engine function supports, else an 
+                exception is raised.
+    
+    RETURNS:
+        Instance of KNN.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as KNNObj.<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("knn", ["computers_train1_clustered", "computers_test1"])
+        
+        # Create teradataml DataFrame objects.
+        computers_test1 = DataFrame.from_table("computers_test1")
+        computers_train1_clustered = DataFrame.from_table("computers_train1_clustered")
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Generate fit object for column "computer_category".
+        fit_obj = OneHotEncodingFit(data=computers_train1_clustered,
+                                    is_input_dense=True,
+                                    target_column="computer_category",
+                                    categorical_values=["ultra", "special"],
+                                    other_column="other")
+
+
+        # Encode "ultra" and "special" values of column "computer_category".
+        computers_train1_encoded = OneHotEncodingTransform(data=computers_train1_clustered,
+                                                           object=fit_obj.result,
+                                                           is_input_dense=True)
+
+        # Example 1: Map the test computer data to "special" category.
+        KNN_out = KNN(train_data = computers_train1_encoded.result,
+                      test_data = computers_test1,
+                      k = 50,
+                      response_column = "computer_category_special",
+                      id_column="id",
+                      output_prob=False,
+                      input_columns = ["price", "speed", "hd", "ram", "screen"],
+                      voting_weight = 1.0,
+                      emit_distances=False)
+
+        # Print the result DataFrame.
+        print(KNN_out.result)
+
+        # Example 2: Get the distance of 10 nearest neighbours based on "price", "speed" and "hd".
+        KNN_out = KNN(train_data = computers_train1_encoded.result,
+                      test_data = computers_test1,
+                      k=10,
+                      model_type="neighbors",
+                      id_column="id",
+                      input_columns = ["price", "speed", "hd"],
+                      emit_distances=True,
+                      emit_neighbors=True)
+
+        # Print the result DataFrame.
+        print(KNN_out.result)
+    """

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

@@ -0,0 +1,134 @@
+def MovingAverage(data=None, target_columns=None, alpha=0.1, start_rows=2, window_size=10,
+                  include_first=False, mavgtype="C", **generic_arguments):
+    """
+    DESCRIPTION:
+        MovingAverage() function computes average values in a series, using the specified moving average type.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the name of the teradataml DataFrame that contains the
+            columns.
+            Types: teradataml DataFrame
+
+        target_columns:
+            Optional Argument.
+            Specifies the input column names for which the moving average is to
+            be computed. If you omit this argument, then the function copies
+            every input column to the output teradataml DataFrame but does not
+            compute moving average.
+            Types: str OR list of Strings (str)
+
+        alpha:
+            Optional Argument.
+            Specifies the damping factor, a value in the range [0, 1], which
+            represents a percentage in the range [0, 100]. For example, if alpha
+            is 0.2, then the damping factor is 20%. A higher alpha discounts
+            older observations faster.
+            Default Value: 0.1
+            Types: float
+
+        start_rows:
+            Optional Argument.
+            Specifies the number of rows at the beginning of the time series that
+            the function "skips" before it begins the calculation of the
+            exponential moving average. The function uses the arithmetic average
+            of these rows as the initial value of the exponential moving average.
+            The value n must be an integer.
+            Default Value: 2
+            Types: int
+
+        window_size:
+            Optional Argument.
+            Specifies the number of previous values to include in the computation
+            of the simple moving average.
+            Default Value: 10
+            Types: int
+
+        include_first:
+            Optional Argument.
+            Specifies whether the first "start_rows" rows should be included in the
+            output or not.
+            Default Value: False
+            Types: bool
+
+        mavgtype:
+            Optional Argument.
+            Specifies the moving average type that needs to be used for computing
+            moving averages of TargetColumns.
+            Default Value: "C"
+            Permitted Values: C, S, M, W, E, T
+            Types: str
+
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept.
+            Below are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the function in a table or not.
+                    When set to True, results are persisted in a table; otherwise, results
+                    are garbage collected at the end of the session.
+                    Default Value: False
+                    Types: boolean
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the function in a volatile table or not.
+                    When set to True, results are stored in a volatile table, otherwise not.
+                    Default Value: False
+                    Types: boolean
+
+            Function allows the user to partition, hash, order or local order the input
+            data. These generic arguments are available for each argument that accepts
+            teradataml DataFrame as input and can be accessed as:
+                * "<input_data_arg_name>_partition_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if the underlying SQL Engine
+                function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of MovingAverage.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as MovingAverageObj.<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("movavg", ["ibm_stock"])
+
+        # Create teradataml DataFrame object.
+        ibm_stock = DataFrame.from_table("ibm_stock")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Compute the average values in a series, using the 'C' moving average type.
+        obj = MovingAverage(data=ibm_stock,
+                            data_partition_column='stockprice',
+                            data_order_column='stockprice',
+                            include_first=False,
+                            alpha=0.1,
+                            start_rows=2,
+                            window_size=10,
+                            mavgtype='C')
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+    """

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

@@ -0,0 +1,121 @@
+def NERExtractor(data=None, user_defined_data=None, rules_data=None, text_column=None,
+                 input_language="EN", show_context=0, accumulate=None,
+                 **generic_arguments):
+    """
+    DESCRIPTION:
+        NERExtractor() performs Named Entity Recognition (NER) on input text 
+        according to user-defined dictionary words or regular expression (regex) patterns.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        user_defined_data:
+            Required Argument.
+            Specifies the teradataml DataFrame which contains user defined words and the corresponding entity label.
+            Types: teradataml DataFrame
+
+        rules_data:
+            Required Argument.
+            Specifies the teradataml DataFrame which contains user-defined regex patterns and the corresponding entity label.
+            Types: teradataml DataFrame
+
+        text_column:
+            Required Argument.
+            Specifies the name of the teradataml DataFrame column that will be used for NER search.
+            Types: str
+
+        input_language:
+            Optional Argument.
+            Specifies the language of input text.
+            Default Value: "EN"
+            Types: str
+
+        show_context:
+            Optional Argument.
+            Specifies the number of words before and after the matched entity. If leading or trailing
+            words are less than "show_context", then ellipsis (...) are added. Must be a positive value
+            less than 10.
+            Default Value: 0
+            Types: int
+
+        accumulate:
+            Optional Argument.
+            Specifies the name(s) of input teradataml DataFrame column(s) to copy to the output.
+            table to output.
+            Types: str or list of str
+
+        **generic_arguments:
+            Optional Argument.
+            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 NERExtractor.
+        Output teradataml DataFrames can be accessed using attribute references, such as TDNERExtractorObj.<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 an error if not supported on the Vantage user is connected to.
+
+        # Load the example data.
+        load_example_data("tdnerextractor", ["ner_input_eng", "ner_dict", "ner_rule"])
+
+        # Create teradataml DataFrame objects.
+        df = DataFrame.from_table("ner_input_eng")
+        user_defined_words = DataFrame.from_table("ner_dict")
+        rules = DataFrame.from_table("ner_rule")
+
+          
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function NERExtractor.
+        from teradataml import NERExtractor
+
+        # Example 1: Perform Named Entity Recognition (NER) using Rules and Dict with Accumulate.
+        NER_out = NERExtractor(data=df,
+                               user_defined_data=user_defined_words,
+                               rules_data=rules,
+                               text_column=["txt"],
+                               input_language="en",
+                               show_context=3,
+                               accumulate=["id"])
+
+        # Print the result DataFrame.
+        print(NER_out.result)
+    """

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

@@ -0,0 +1,209 @@
+def NGramSplitter(data=None, text_column=None, delimiter=" ", grams=None, overlapping=True, to_lower_case=True,
+                  punctuation="`~#^&*()-", reset=".,?!", total_gram_count=False, total_count_column="totalcnt",
+                  accumulate=None, n_gram_column="ngram", num_grams_column="n", frequency_column="frequency",
+                  **generic_arguments):
+    """
+    DESCRIPTION:
+        The NGramSplitter function tokenizes (splits) an input stream of text and
+        outputs n multigrams (called n-grams) based on the specified
+        delimiter and reset parameters. NGramSplitter provides more flexibility than
+        standard tokenization when performing text analysis. Many two-word
+        phrases carry important meaning (for example, "machine learning")
+        that unigrams (single-word tokens) do not capture. This, combined
+        with additional analytical techniques, can be useful for performing
+        sentiment analysis, topic identification and document classification.
+
+        Note: This function is only available when teradataml is connected
+              to Vantage 1.1 or later versions.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies input teradataml DataFrame, where each row contains a document
+            to be tokenized. The input teradataml DataFrame can have additional rows,
+            some or all of which the function returns in the output table.
+            Types: teradataml DataFrame
+
+        text_column:
+            Required Argument.
+            Specifies the name of the column that contains the input text. The column
+            must have a SQL string data type.
+            Types: str
+
+        delimiter:
+            Optional Argument.
+            Specifies a character or string or a regular expression that separates words in the input text. The
+            default value is the set of all whitespace characters which includes
+            the characters for space, tab, newline, carriage return and some
+            others.
+            Default Value: "[\\s]+"
+            Types: str
+
+        grams:
+            Required Argument.
+            Specifies the length, in words, of each n-gram (that is, the value of n).
+            A value_range has the syntax integer1 - integer2, where integer1 <= integer2.
+            The values of n, integer1, and integer2 must be positive.
+            Types: str
+
+        overlapping:
+            Optional Argument.
+            Specifies a Boolean value that specifies whether the function allows
+            overlapping n-grams. When this value is "true" (the default), each
+            word in each sentence starts an n-gram, if enough words follow it (in
+            the same sentence) to form a whole n-gram of the specified size. For
+            information on sentences, see the description of the reset argument.
+            Default Value: True
+            Types: bool
+
+        to_lower_case:
+            Optional Argument.
+            Specifies a Boolean value that specifies whether the function converts all
+            letters in the input text to lowercase.
+            Default Value: True
+            Types: bool
+
+        punctuation:
+            Optional Argument.
+            Specifies a string or a regular expression that specifies the punctuation characters for the function
+            to remove before evaluating the input text.
+            Default Value: "`~#^&*()-"
+            Types: str
+
+        reset:
+            Optional Argument.
+            Specifies a string or a regular expression that specifies the character or string that ends a sentence.
+            At the end of a sentence, the function discards any partial n-grams and searches
+            for the next n-gram at the beginning of the next sentence. An n-gram
+            cannot span two sentences.
+            Default Value: ".,?!"
+            Types: str
+
+        total_gram_count:
+            Optional Argument.
+            Specifies whether the function returns the total
+            number of ngrams in the document (that is, in the row). If you
+            specify "true", then the name of the returned column is specified by
+            the total_count_column argument.
+            Note: The total number of n-grams is not necessarily the number
+            of unique ngrams.
+            Default Value: False
+            Types: bool
+
+        total_count_column:
+            Optional Argument.
+            Specifies the name of the column to return if the value of the total_gram_count
+            argument is True.
+            Default Value: "totalcnt"
+            Types: str
+
+        accumulate:
+            Optional Argument.
+            Specifies the names of the columns to return for each n-gram. These columns
+            cannot have the same names as those specified by the arguments ngram,
+            num_grams_column, and total_count_column. By default, the function
+            returns all input columns for each n-gram.
+            Types: str OR list of Strings (str)
+
+        n_gram_column:
+            Optional Argument.
+            Specifies the name of the column that is to contain the generated n-grams.
+            Default Value: "ngram"
+            Types: str
+
+        num_grams_column:
+            Optional Argument.
+            Specifies the name of the column that is to contain the length of n-gram (in
+            words).
+            Default Value: "n"
+            Types: str
+
+        frequency_column:
+            Optional Argument.
+            Specifies the name of the column that is to contain the count of each unique
+            n-gram (that is, the number of times that each unique n-gram appears
+            in the document).
+            Default Value: "frequency"
+            Types: str
+
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept.
+            Below are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the function in a table or not.
+                    When set to True, results are persisted in a table; otherwise, results
+                    are garbage collected at the end of the session.
+                    Default Value: False
+                    Types: boolean
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the function in a volatile table or not.
+                    When set to True, results are stored in a volatile table, otherwise not.
+                    Default Value: False
+                    Types: boolean
+
+            Function allows the user to partition, hash, order or local order the input
+            data. These generic arguments are available for each argument that accepts
+            teradataml DataFrame as input and can be accessed as:
+                * "<input_data_arg_name>_partition_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if the underlying SQL Engine
+                function supports, else an exception is raised.
+
+
+    RETURNS:
+        Instance of NGramSplitter.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as ngramsplitterObj.<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("ngrams", ["paragraphs_input"])
+
+        # Create teradataml DataFrame object.
+        paragraphs_input = DataFrame.from_table("paragraphs_input")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Creating teradataml dataframe by calculating the
+        #            similarity between two strings.
+        obj = NGramSplitter(data=paragraphs_input,
+                            text_column='paratext',
+                            n_gram_column='ngram',
+                            num_grams_column='n',
+                            frequency_column='frequency',
+                            total_count_column='totalcnt',
+                            grams='4-6',
+                            overlapping=True,
+                            to_lower_case=True,
+                            delimiter=' ',
+                            punctuation='`~#^&*()-',
+                            reset='.,?!',
+                            total_gram_count=False)
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+
+    """