teradataml 20.0.0.4__py3-none-any.whl → 20.0.0.5__py3-none-any.whl

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

@@ -0,0 +1,138 @@
+def Apriori(data=None, target_column=None, id_column=None, partition_columns=None,
+            max_len=2, delimiter=",", is_dense_input=False, patterns_or_rules=None,
+            support=0.01, **generic_arguments):
+    """
+    DESCRIPTION:
+        The Apriori() function finds patterns and calculates different statistical metrics to
+        understand the influence of the occurrence of a set of items on others.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        target_column:
+            Required Argument.
+            Specifies the input teradataml DataFrame column which contains the data to filter.
+            Types: str
+
+        id_column:
+            Optional Argument.
+            Specifies the name of the column that uniquely groups the items that are purchased together. 
+            Applicable only when `is_dense_input` is False.
+            Types: str
+
+        partition_columns:
+            Optional Argument.
+            Specifies the column name(s) in the "data" to partition the input.
+            Types: str or list of str
+
+        max_len:
+            Optional Argument.
+            Specifies the maximum number of items in the item set. 
+            "max_len" must be greater than or equal to 1 and less than or equal to 20.
+            Default Value: 2
+            Types: int
+
+        delimiter:
+            Optional Argument, Required when "is_dense_input" is set to True.
+            Specifies a character or string that separates words in the input text.
+            Default Value: ","
+            Types: str
+
+
+        is_dense_input:
+            Optional Argument.
+            Specifies whether input data is in dense format or not. 
+            When set to True, function considers the  data is in dense format. 
+            Otherwise function considers  data is not in dense format.
+            Default Value: False
+            Types: bool
+
+        patterns_or_rules:
+            Optional Argument.
+            Specifies whether to emit PATTERNS or RULES as output.
+            Permitted Values: "PATTERNS", "RULES"
+            Types: str
+
+        support:
+            Optional Argument.
+            Specifies the support value (minimum occurrence threshold) of the itemset.
+            Default Value: 0.01
+            Types: float
+
+        **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 Apriori.
+        Output teradataml DataFrames can be accessed using attribute references, such as AprioriObj.<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("apriori", ["trans_dense","trans_sparse"])
+
+        # Create teradataml DataFrame objects.
+        dense_table = DataFrame.from_table("trans_dense")
+        sparse_table = DataFrame.from_table("trans_sparse")
+
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function Apriori.
+        from teradataml import Apriori
+
+        # Example 1: Find patterns in the input data with DENSE DATA, PARTITION,RULES .
+        Apriori_out = Apriori(data=dense_table, target_column="item",
+                              partition_columns=["location"], max_len=2,
+                              patterns_or_rules="rules", support=0.01)
+
+        # Print the result DataFrame.
+        print(Apriori_out.result)
+
+        # Example 2: Find patterns in the input data with SPARSE DATA, NO PARTITIONS, PATTERNS.
+        Apriori_out = Apriori(data=sparse_table, target_column="item",
+                              id_column="tranid", max_len=3)
+                                    
+        # Print the result DataFrame.
+        print(Apriori_out.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

@@ -33,7 +33,7 @@ def NGramSplitter(data=None, text_column=None, delimiter=" ", grams=None, overla
 
         delimiter:
             Optional Argument.
-            Specifies a character or string that separates words in the input text. The
+            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.
@@ -66,14 +66,14 @@ def NGramSplitter(data=None, text_column=None, delimiter=" ", grams=None, overla
 
         punctuation:
             Optional Argument.
-            Specifies a string that specifies the punctuation characters for the function
+            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 that specifies the character or string that ends a sentence.
+            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.

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

@@ -0,0 +1,212 @@
+def SMOTE(data = None, encoding_data = None, id_column = None,
+          response_column = None, input_columns = None, categorical_columns = None,
+          median_standard_deviation = None, minority_class = None,
+          oversampling_factor = 5, sampling_strategy = "smote",
+          fill_sampleid = True, noninput_columns_value = "sample", n_neighbors = 5,
+          seed = None, **generic_arguments):
+    """
+    DESCRIPTION:
+        SMOTE() function generates data by oversampling a minority class using 
+        smote, adasyn, borderline-2 or smote-nc algorithms.
+    
+    
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+        
+        encoding_data:
+            Optional Argument, Required when "sampling_strategy" is set to 'smotenc' algorithm.
+            Specifies the teradataml dataframe containing the ordinal encoding information.
+            Types: teradataml DataFrame
+        
+        id_column:
+            Required Argument.
+            Specifies the name of the column in "data" that 
+            uniquely identifies a data sample.
+            Types: str
+        
+        response_column:
+            Optional Argument.
+            Specifies the name of the column in "data" that contains the 
+            numeric value to be used as the response value for a sample.
+            Types: str
+        
+        input_columns:
+            Required Argument.
+            Specifies the name of the input columns in "data" for oversampling.
+            Types: str OR list of Strings (str)
+        
+        categorical_columns:
+            Optional Argument, Required when "sampling_strategy" is set to 'smotenc' algorithm.
+            Specifies the name of the categorical columns in the "data" that 
+            the function uses for oversampling with smotenc.
+            Types: str OR list of Strings (str)
+        
+        median_standard_deviation:
+            Optional Argument, Required when "sampling_strategy" is set to 'smotenc' algorithm.
+            Specifies the median of the standard deviations computed over the 
+            numerical input columns.
+            Types: float
+        
+        minority_class:
+            Required Argument.
+            Specifies the minority class for which synthetic samples need to be 
+            generated. 
+            Note:
+                * The label for minority class under response column must be numeric integer.
+            Types: str
+        
+        oversampling_factor:
+            Optional Argument.
+            Specifies the factor for oversampling the minority class.
+            Default Value: 5
+            Types: float
+        
+        sampling_strategy:
+            Optional Argument.
+            Specifies the oversampling algorithm to be used to create synthetic samples.
+            Default Value: "smote"
+            Permitted Values: "smote", "adasyn", "borderline", "smotenc"
+            Types: str
+        
+        fill_sampleid:
+            Optional Argument.
+            Specifies whether to include the id of the original observation used 
+            to generate each synthetic observation.
+            Default Value: True
+            Types: bool
+        
+        noninput_columns_value:
+            Optional Argument.
+            Specifies the value to put in a sample column for columns not 
+            specified as input columns.
+            Default Value: "sample"
+            Permitted Values: "sample", "neighbor", "null"
+            Types: str
+        
+        n_neighbors:
+            Optional Argument.
+            Specifies the number of nearest neighbors for choosing the sample to 
+            be used in oversampling.
+            Default Value: 5
+            Types: int
+        
+        seed:
+            Optional Argument.
+            Specifies the random seed the algorithm uses for repeatable results. 
+            The function uses the seed for random interpolation and generate the 
+            synthetic sample.
+            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 SMOTE.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as SMOTEObj.<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("dataframe", "iris_test")
+        load_example_data("teradataml", "titanic")
+        
+        # Create teradataml DataFrame objects.
+        iris_input = DataFrame.from_table("iris_test").iloc[:25]
+        titanic_input = DataFrame("titanic").iloc[:50]
+
+        # Create Encoding DataFrame objects.
+        encoded_data = OrdinalEncodingFit(data=titanic_input,
+                                          target_column=['sex','embarked'],
+                                          approach="AUTO")
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function SMOTE.
+        from teradataml import SMOTE
+        
+        # Example 1 : Generate synthetic samples using smote algorithm.
+        smote_out = SMOTE(data = iris_input,
+                          n_neighbors = 5,
+                          id_column='id',
+                          minority_class='3',
+                          response_column='species',
+                          input_columns =['sepal_length', 'sepal_width', 'petal_length', 'petal_width'],
+                          oversampling_factor=2,
+                          sampling_strategy='smote',
+                          seed=10)
+        
+        # Print the result DataFrame.
+        print(smote_out.result)
+
+        # Example 2 : Generate synthetic samples using smotenc algorithm with categorical columns.
+        smote_out2 = SMOTE(data = titanic_input, 
+                           encoding_data = encoded_data.result, 
+                           id_column = 'passenger', 
+                           response_column = 'survived', 
+                           input_columns = ['parch', 'age', 'sibsp'], 
+                           categorical_columns = ['sex', 'embarked'],
+                           median_standard_deviation = 31.47806044604718,
+                           minority_class = '1', 
+                           oversampling_factor = 5,
+                           sampling_strategy = "smotenc", 
+                           noninput_columns_value = "null", 
+                           n_neighbors = 5)
+        
+        # Print the result DataFrame.
+        print(smote_out2.result)
+    """

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

@@ -0,0 +1,119 @@
+def TextMorph(data=None, word_column=None, pos=None,
+              single_output=False, postag_column=None,
+              accumulate=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        TextMorph() function generate morphs of given words in the input dataset.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        word_column:
+            Required Argument.
+            Specifies the name of the input column that contains words for which morphs are to be generated.
+            Types: str
+
+        pos:
+            Optional Argument.
+            Specifies the part of speech (POS) to output.
+            Permitted Values: "NOUN", "VERB", "ADV", "ADJ"
+            Types: str or list of str
+
+        single_output:
+            Optional Argument.
+            Specifies whether to output only one morph for each word. If set to `False`, 
+            the function outputs all morphs for each word.
+            Default Value: False
+            Types: bool
+
+        postag_column:
+            Optional Argument.
+            Specifies the name of the  column in data that contains the part-of-speech (POS) 
+            tags of the words, output by the function TD_POSTagger.
+            Types: str
+
+        accumulate:
+            Optional Argument.
+            Specifies the names of the input columns to copy to the output table.
+            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 TextMorph.
+        Output teradataml DataFrames can be accessed using attribute references, such as TDTextMorphObj.<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("textmorph", ["words_input","pos_input"])
+
+        # Create teradataml DataFrame objects.
+        data1 = DataFrame.from_table("words_input")
+        data2 = DataFrame.from_table("pos_input")
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function TextMorph.
+        from teradataml import TextMorph
+
+        # Example 1: Generate morphs for words in the input dataset.
+        TextMorph_out = TextMorph(data=data1,
+                                  word_column="data2",
+                                  pos=["noun", "verb"],
+                                  single_output=True,
+                                  accumulate=["id"])
+
+        # Print the result DataFrame.
+        print(TextMorph_out.result)
+
+        Example 2 : Generate morphs for words in the input dataset with POS tags.
+        TextMorph_pos = TextMorph(data=data2,
+                                  word_column="word",
+                                  postag_column="pos_tag",
+                                  accumulate=["id","pos_tag"])
+
+        # Print the result DataFrame.
+        print(TextMorph_pos.result)
+    """