teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,224 @@
+def TextParser(data=None, object=None, text_column=None, enforce_token_limit=False,
+               convert_to_lowercase=True, stem_tokens=False, remove_stopwords=False,
+               accumulate=None, delimiter=" \t\n\f\r", delimiter_regex=None,
+               punctuation=r"!#$%&()*+,-./:;?@\^_`{|}~", token_col_name=None,
+               doc_id_column=None, list_positions=False, token_frequency=False,
+               output_by_word=True, **generic_arguments):
+    """
+    DESCRIPTION:
+        The TextParser() function can parse text and perform the following operations:
+            * Tokenize the text in the specified column
+            * Remove the punctuations from the text and convert the text to lowercase
+            * Remove stop words from the text and convert the text to their root forms
+            * Create a row for each word in the output dataframe
+            * Perform stemming; that is, the function identifies the common root form of a word
+              by removing or replacing word suffixes
+            
+            Notes:
+                * The stems resulting from stemming may not be actual words. For example, the stem
+                  for 'communicate' is 'commun' and the stem for 'early' is 'earli'
+                  (trailing 'y' is replaced by 'i').
+                * This function requires the UTF8 client character set.
+                * This function does not support Pass Through Characters (PTCs).
+                * For information about PTCs, see Teradata Vantage™ - Analytics Database International
+                   Character Set Support.
+                * This function does not support KanjiSJIS or Graphic data types.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        object:
+            Optional Argument.
+            Specifies the teradataml DataFrame containing stop words.
+            Types: teradataml DataFrame
+
+        text_column:
+            Required Argument.
+            Specifies the name of the input data column whose contents are to be tokenized.
+            Types: str
+
+        enforce_token_limit:
+            Optional Argument.
+            Specifies whether to throw an informative error when finding token larger than
+            64K/32K or silently discard those larger tokens.
+            Default Value: False
+            Types: bool
+
+        convert_to_lowercase:
+            Optional Argument.
+            Specifies whether to convert the text in "text_column" to lowercase.
+            Default Value: True
+            Types: bool
+
+        stem_tokens:
+            Optional Argument.
+            Specifies whether to convert the text in "text_column" to their root forms.
+            Default Value: False
+            Types: bool
+
+        remove_stopwords:
+            Optional Argument.
+            Specifies whether to remove stop words from the text in "text_column" before
+            parsing.
+            Default Value: False
+            Types: bool
+
+        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)
+
+        delimiter:
+            Optional Argument.
+            Specifies the word delimiter to apply to the text in the specified column in the 
+            "text_column" element.
+            Default Value: " \\t\\n\\f\\r"
+            Types: str
+
+        delimiter_regex:
+            Optional Argument.
+            Specifies a Perl Compatible regular expression that represents the word delimiter.
+            Types: str
+
+        punctuation:
+            Optional Argument.
+            Specifies the punctuation characters to replace with a space in the input text.
+            Default Value: "!#$%&()*+,-./:;?@\\^_`{|}~"
+            Types: str
+
+        token_col_name:
+            Optional Argument.
+            Specifies the name for the output column that contains the individual words from
+            the text of the specified column in the "text_column" element.
+            Types: str
+
+        doc_id_column:
+            Optional Argument.
+            Specifies the name of the column that uniquely identifies a row in the input table.
+            Types: str
+
+        list_positions:
+            Optional Argument.
+            Specifies whether to output the positions of a word in list form.
+            Default Value: False
+            Types: bool
+        
+        token_frequency:
+            Optional Argument.
+            Specifies whether to output the frequency for each token.
+            Default Value: False
+            Types: bool
+
+        output_by_word:
+            Optional Argument.
+            Specifies whether to output each token in a separate row or all tokens in one.
+            Default Value: True
+            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 boolean
+            Note:
+                These generic arguments are supported by teradataml if 
+                the underlying SQL Engine function supports, else an 
+                exception is raised.
+
+    RETURNS:
+        Instance of TextParser.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as TextParserObj.<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("textparser", ["complaints", "stop_words"])
+
+        # Create teradataml DataFrame objects.
+        complaints = DataFrame.from_table("complaints")
+        stop_words = DataFrame.from_table("stop_words")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1 : Remove all the stop words from "text_data" column
+        #             and accumulate it by "doc_id" column.
+        TextParser_out = TextParser(data=complaints,
+                                    text_column="text_data",
+                                    object=stop_words,
+                                    remove_stopwords=True,
+                                    accumulate="doc_id")
+
+        # Print the result DataFrame.
+        print(TextParser_out.result)
+
+        # Example 2 : Convert words in "text_data" column into their root forms.
+        TextParser_out = TextParser(data=complaints,
+                                    text_column="text_data",
+                                    convert_to_lowercase=True,
+                                    stem_tokens=True)
+
+        # Print the result DataFrame.
+        print(TextParser_out.result)
+
+        # Example 3 : Tokenize  words in "text_data" column using delimiter regex,
+        #             convert tokens to lowercase and output token positions in a list format
+        TextParser_out = TextParser(data=complaints,
+                                    text_column="text_data",
+                                    doc_id_column="doc_id",
+                                    delimeter_regex="[ \t\f\r\n]+",
+                                    list_positions=True,
+                                    convert_to_lowercase=True,
+                                    output_by_word=False)
+ 
+        # Print the result DataFrame.
+        print(TextParser_out.result)
+    """

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

@@ -0,0 +1,160 @@
+def TrainTestSplit(data=None, id_column=None, stratify_column=None,
+                   seed=None, train_size=0.75, test_size=0.25,
+                   **generic_arguments):
+        """
+        DESCRIPTION:
+            The TrainTestSplit() function simulates how a model would
+            perform on new data. The function divides the dataset into
+            train and test subsets to evaluate machine learning algorithms
+            and validate processes. The first subset is used to train
+            the model. The second subset is used to make predictions and
+            compare the predictions to actual values.
+
+            Notes:
+                * The TrainTestSplit() function gives consistent results
+                  across multiple runs on same machine. With different machines,
+                  it might produce different train and test datasets.
+                * Requires the UTF8 client character set for UNICODE data.
+                * Does not support Pass Through Characters (PTCs).
+                * Does not support KanjiSJIS or graphic data types.
+        
+        
+        PARAMETERS:
+            data:
+                Required Argument.
+                Specifies the input teradataml DataFrame on which split
+                to be performed.
+                Types: teradataml DataFrame
+            
+            id_column:
+                Optional Argument.
+                Specifies the input data column name that has the
+                unique identifier for each row in the input.
+                Notes:
+                    * Mandatory when "seed" argument is present so that the
+                      output of TrainTestSplit() function is deterministic
+                      across multiple function calls.
+                Types: str
+            
+            stratify_column:
+                Optional Argument.
+                Specifies column name that contains the labels indicating
+                which data needs to be stratified.
+                Types: str
+            
+            seed:
+                Optional Argument.
+                Specifies the seed value that controls the shuffling applied
+                to the data before applying the split. Pass an int for reproducible
+                output across multiple function calls.
+                Notes:
+                    * When the argument is not specified, different
+                      runs of the query generate different outputs.
+                    * It must be in the range [0, 2147483647]
+                Types: int
+            
+            train_size:
+                Optional Argument.
+                Specifies the size of the train dataset.
+                Notes:
+                    * If both "train_size" and "test_size" arguments are specified,
+                      then their sum must be equal to 1.
+                    * "train_size" and "test_size" should be greater than the number
+                      of classes when using stratify.
+                    * If the input data does not have an identifier column, then
+                      FillRowId() function can be used to generate one.
+                    * It must be in the range (0, 1)
+                Default Value: 0.75
+                Types: float
+            
+            test_size:
+                Optional Argument.
+                Specifies the size of the test dataset.
+                Note:
+                    * It must be in the range (0, 1)
+                Default Value: 0.25
+                Types: float
+            
+            **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 TrainTestSplit.
+            Output teradataml DataFrames can be accessed using attribute 
+            references, such as TrainTestSplitObj.<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 objects.
+            data_input = DataFrame.from_table("titanic")
+            
+            # Check the list of available analytic functions.
+            display_analytic_functions()
+            
+            # Example 1 : Split the input data to test dataset and train dataset,
+            #             with ratio of test:train is 20:80. Note that output
+            #             of TrainTestSplit() function contains 'TD_IsTrainRow'
+            #             column in which '0' represent test data and '1'
+            #             represent train data.
+            TrainTestSplit_out = TrainTestSplit(data = data_input,
+                                                id_column="passenger",
+                                                train_size=0.80,
+                                                test_size=0.20,
+                                                seed=42)
+            
+            # Print the result DataFrame.
+            print(TrainTestSplit_out.result)
+        
+        """

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

@@ -0,0 +1,123 @@
+def Transform(data=None, object=None, id_columns=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The Transform() function applies numeric transformations to input columns,
+        using Fit() output.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame which contains the model data generated by
+            the Fit() function or instance of Fit.
+            Types: teradataml DataFrame or Fit
+
+        id_columns:
+            Optional Argument.
+            Specifies the input teradataml DataFrame numeric columns to exactly
+            copy to the output. By default, all numeric columns will be converted
+            to float.
+            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 Transform.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as TransformObj.<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", ["iris_input", "transformation_table"])
+
+        # Create teradataml DataFrame objects.
+        iris_input = DataFrame.from_table("iris_input")
+        transformation_df = DataFrame.from_table("transformation_table")
+        transformation_df = transformation_df.drop(['id'], axis=0)
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Run Fit() with all arguments which will validate numeric
+        # transformations can be applied or not present in transformation_df DataFrame.
+        # and pass the output to Transform().
+        fit_df = Fit(data=iris_input,
+                     object=transformation_df,
+                     object_order_column='TargetColumn'
+                     )
+
+        # Run Transform() with persist as True in order to save the result.
+        # Note that teradataml DataFrame representing the model is passed as
+        # input to "object".
+        transform_result = Transform(data=iris_input,
+                                     data_partition_column='sepal_length',
+                                     data_order_column='sepal_length',
+                                     object=fit_df.result,
+                                     object_order_column='TargetColumn',
+                                     id_columns=['species', 'id'],
+                                     persist=True
+                                     )
+
+        # Print the result DataFrame.
+        print(transform_result.result)
+
+        # Example 2: Transform the 'petal_length', 'sepal_length', 'petal_width',
+        #            'sepal_width' according to transformation_df DataFrame.
+        #            Note that model is passed as instance of FIT to "object".
+        transform_result1 = Transform(data=iris_input,
+                                      data_partition_column='sepal_length',
+                                      data_order_column='sepal_length',
+                                      object=fit_df,
+                                      object_order_column='TargetColumn',
+                                      id_columns=['species', 'id'],
+                                      persist=True
+                                      )
+
+        # Print the result DataFrame.
+        print(transform_result1.result)
+    """

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

@@ -0,0 +1,142 @@
+def UnivariateStatistics(newdata=None, target_columns=None, partition_columns=None,
+                         stats='ALL', centiles=[1, 5, 10, 25, 50, 75, 90, 95, 99],
+                         trim_percentile=20, **generic_arguments):
+    """
+    DESCRIPTION:
+        UnivariateStatistics() function displays descriptive statistics for each specified numeric input DataFrame column.
+
+    PARAMETERS:
+        newdata:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        target_columns:
+            Required Argument.
+            Specifies the name(s) of the column(s) in "data" for which univariate
+            statistics need to be displayed.
+            Types: str OR list of Strings (str)
+
+        partition_columns:
+            Optional Argument.
+            Specifies the names of the input partition columns.
+            Types: str OR list of Strings (str)
+
+        stats:
+            Optional Argument.
+            Specifies the statistics to calculate.
+            Permitted Values:
+                * SUM
+                * COUNT or CNT
+                * MAXIMUM or MAX
+                * MINIMUM or MIN
+                * MEAN
+                * UNCORRECTED SUM OF SQUARES or USS
+                * NULL COUNT or NLC
+                * POSITIVE VALUES COUNT or PVC
+                * NEGATIVE VALUES COUNT or NVC
+                * ZERO VALUES COUNT or ZVC
+                * TOP5 or TOP
+                * BOTTOM5 or BTM
+                * RANGE or RNG
+                * GEOMETRIC MEAN or GM
+                * HARMONIC MEAN or HM
+                * VARIANCE or VAR
+                * STANDARD DEVIATION or STD
+                * STANDARD ERROR or SE
+                * SKEWNESS or SKW
+                * KURTOSIS or KUR
+                * COEFFICIENT OF VARIATION or CV
+                * CORRECTED SUM OF SQUARES or CSS
+                * MODE
+                * MEDIAN or MED
+                * UNIQUE ENTITY COUNT or UEC
+                * INTERQUARTILE RANGE or IQR
+                * TRIMMED MEAN or TM
+                * PERCENTILES or PRC
+                * ALL
+            Default Value: 'ALL'
+            Types: str OR list of Strings (str)
+
+        centiles:
+            Optional Argument.
+            Specifies the percentile to calculate.
+            The function ignores Centiles unless Stats specifies PERCENTILES, PRC, or ALL.
+            Default Value: [1, 5, 10, 25, 50, 75, 90, 95, 99]
+            Types: int or list of int
+
+        trim_percentile:
+            Optional Argument.
+            Specifies the trimmed lower percentile.
+            Default Value: 20
+            Types: int
+
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept.
+            Below are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the function in a table or not.
+                    When set to True, results are persisted in a table; otherwise, results
+                    are garbage collected at the end of the session.
+                    Default Value: False
+                    Types: boolean
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the function in a volatile table or not.
+                    When set to True, results are stored in a volatile table, otherwise not.
+                    Default Value: False
+                    Types: boolean
+
+            Function allows the user to partition, hash, order or local order the input
+            data. These generic arguments are available for each argument that accepts
+            teradataml DataFrame as input and can be accessed as:
+                * "<input_data_arg_name>_partition_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if the underlying SQL Engine
+                function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of UnivariateStatistics.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as UnivariateStatisticsObj.<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: Display descriptive statistics of input DataFrame
+        #            column "fare" by partitioning "sex" and "age".
+        obj = UnivariateStatistics(newdata=titanic_data,
+                                   target_columns='fare',
+                                   partition_columns=['sex', 'age'],
+                                   stats='ALL',
+                                   centiles=[1, 5, 10, 25, 50, 75, 90, 95, 99],
+                                   trim_percentile=20)
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+    """