teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,166 @@
+def ClassificationEvaluator(data=None,
+                            observation_column=None,
+                            prediction_column=None,
+                            num_labels=None,
+                            labels=None,
+                            **generic_arguments):
+    """
+    DESCRIPTION:
+        In classification problems, a confusion matrix is used to visualize the
+        performance of a classifier. The confusion matrix contains predicted labels
+        represented across the row-axis and actual labels represented across the column-axis.
+        Each cell in the confusion matrix corresponds to the count of occurrences
+        of labels in the test data. The ClassificationEvaluator() function evaluate
+        and emits various metrics of classification model based on its predictions on the data.
+        Apart from accuracy, the secondary output data returns micro, macro, and weighted-averaged
+        metrics of precision, recall, and F1-score values.
+        Notes:
+             * The function works for multi-class scenarios as well. In any case, the
+               primary output data contains class-level metrics, whereas the secondary
+               output data contains metrics that are applicable across classes.
+             * The function works only when columns specified in 'observation_column'
+               and 'prediction_column' has same teradata types.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the teradataml DataFrame, containing expected and predicted labels.
+            Types: teradataml DataFrame
+
+        observation_column:
+            Required Argument.
+            Specifies the column name in "data" containing observation labels.
+            Types: str
+
+        prediction_column:
+            Required Argument.
+            Specifies the column name in "data" containing predicted labels.
+            Types: str
+
+        num_labels:
+            Optional Argument.
+            Specifies the number of labels in the dataset.
+            Note:
+                Argument is ignored if "labels" argument is used.
+            Allowed Values: 1 <= num_labels <= 512
+            Types: int
+
+        labels:
+            Optional Argument.
+            Specifies the list of all predicted labels in the input.
+            Provide either "num_labels" argument or "labels" argument.
+            Types: str OR list of 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 SQL Engine function supports, else an
+                exception is raised.
+
+    RETURNS:
+        Instance of ClassificationEvaluator.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as  ClassificationEvaluatorObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            1. result
+            2. output_data
+
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+
+
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage to execute the function.
+        #     2. One must import the required functions mentioned in
+        #        the example from teradataml.
+        #     3. Function will raise error if not supported on the Vantage
+        #        user is connected to.
+
+        # Example 1 : Evaluate the classification model generated to predict the labels
+        #             'crash', 'nocrash' using the predicted data.
+
+        # 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()
+
+        # Tokenize the "text_column" and accumulate result by "doc_id" and "category".
+        complaints_tokenized = TextParser(data=complaints,
+                                          text_column="text_data",
+                                          object=stop_words,
+                                          remove_stopwords=True,
+                                          accumulate=["doc_id", "category"])
+
+        # Calculate the conditional probabilities for token-category pairs.
+        NaiveBayesTextClassifierTrainer_out = NaiveBayesTextClassifierTrainer(data=complaints_tokenized.result,
+                                                                              token_column="token",
+                                                                              doc_category_column="category")
+
+        # Print the result DataFrames.
+        print(NaiveBayesTextClassifierTrainer_out.result)
+        print(NaiveBayesTextClassifierTrainer_out.model_data)
+
+        # Score the data using NaiveBayesTextClassifierPredict() on model generated by
+        # NaiveBayesTextClassifier() where model_type is "MULTINOMIAL".
+        nbt_predict_out = NaiveBayesTextClassifierPredict(object = NaiveBayesTextClassifierTrainer_out.model_data,
+                                                          newdata = complaints_tokenized.result,
+                                                          input_token_column = 'token',
+                                                          accumulate="category",
+                                                          doc_id_columns = 'doc_id')
+
+        # Print the result DataFrame.
+        print(nbt_predict_out.result)
+
+        # Convert prediction column and category column to same DataType.
+        predicted_data = ConvertTo(data = nbt_predict_out.result,
+                                   target_columns = ["category", "prediction"],
+                                   target_datatype = ["VARCHAR(charlen=20,charset=UNICODE,casespecific=NO)"])
+
+        # Evaluate classification.
+        ClassificationEvaluator_obj = ClassificationEvaluator(data=predicted_data.result,
+                                                              observation_column='category',
+                                                              prediction_column='prediction',
+                                                              labels=['no_crash','crash'])
+
+        # Print the result DataFrames.
+        print(ClassificationEvaluator_obj.result)
+        print(ClassificationEvaluator_obj.output_data)
+    """

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

@@ -0,0 +1,86 @@
+def ColumnSummary(data = None, target_columns = None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The ColumnSummary() function can be used to take a quick look at the columns,
+        their datatypes, and summary of NULLs/non-NULLs for a given table.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        target_columns:
+            Required Argument.
+            Specifies the input teradataml DataFrame columns for which column
+            summary needs to be determined.
+            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 ColumnSummary.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as ColumnSummaryObj.<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: Find datatypes, NULL and non-NULL counts etc.
+        obj = ColumnSummary(data=titanic_data,
+                            target_columns=['age', 'pclass', 'embarked', 'cabin']
+                           )
+
+        # Print the result DataFrame.
+        print(obj.result)
+        
+    """

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

@@ -0,0 +1,246 @@
+def ColumnTransformer(input_data = None, bincode_fit_data = None, function_fit_data = None,
+                      nonlinearcombine_fit_data = None, onehotencoding_fit_data = None,
+                      ordinalencoding_fit_data = None, outlierfilter_fit_data = None,
+                      polynomialfeatures_fit_data = None, rownormalize_fit_data = None, scale_fit_data = None,
+                      simpleimpute_fit_data = None, fillrowid_column_name = None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The ColumnTransformer() function transforms the input data columns in a single operation.Provide only
+        the FIT dataframes generated by the Fit analytic functions, and the function runs all transformations
+        that user require in a single operation.
+        The function performs the following transformations:
+                * Scale Transform
+                * Bincode Transform
+                * Function Transform
+                * NonLinearCombine Transform
+                * OutlierFilter Transform
+                * PolynomialFeatures Transform
+                * RowNormalize Transform
+                * OrdinalEncoding Transform
+                * OneHotEncoding Transform
+                * SimpleImpute Transform
+        User must create the FIT dataframe before using the function and must be provided in the same order
+        as in the training data sequence to transform the dataset. The FIT dataframe can have maximum of
+        128 columns.
+        Note:
+            * ColumnTransformer() function works only with python 3.6 and above.
+
+
+    PARAMETERS:
+        input_data:
+            Required Argument.
+            Specifies the teradataml DataFrame that contains input data.
+            Types: teradataml DataFrame
+
+        bincode_fit_data:
+            Optional Argument.
+            Specifies the teradataml DataFrame generated by the BincodeFit() function.
+            Types: teradataml DataFrame
+
+        function_fit_data:
+            Optional Argument.
+            Specifies the teradataml DataFrame generated by the Fit() function.
+            Types: teradataml DataFrame
+
+        nonlinearcombine_fit_data:
+            Optional Argument.
+            Specifies the teradataml DataFrame generated by the NonLinearCombineFit() function.
+            One can pass multiple NonLinearCombineFit() function's output using argument names
+            as nonlinearcombine_fit_data1, nonlinearcombine_fit_data2 and so on.
+            Notes:
+                    * Function considers the arguments which are in sequence and ignores the arguments
+                    which are out of sequence.
+                    Example - If arguments are nonlinearcombine_fit_data, nonlinearcombine_fit_data1,
+                    nonlinearcombine_fit_data2, nonlinearcombine_fit_data4, the function considers only
+                    nonlinearcombine_fit_data, nonlinearcombine_fit_data1 and nonlinearcombine_fit_data2
+                    for processing and ignores nonlinearcombine_fit_data4 since it is out of sequence.
+                    * Argument sequence starts from "nonlinearcombine_fit_data", followed by
+                    "nonlinearcombine_fit_data1", "nonlinearcombine_fit_data2", so on..
+            Types: teradataml DataFrame
+
+        onehotencoding_fit_data:
+            Optional Argument.
+            Specifies the teradataml DataFrame generated by the OneHotEncodingFit() function.
+            Types: teradataml DataFrame
+
+        ordinalencoding_fit_data:
+            Optional Argument.
+            Specifies the teradataml DataFrame generated by the OrdinalEncodingFit() function.
+            Types: teradataml DataFrame
+
+        outlierfilter_fit_data:
+            Optional Argument.
+            Specifies the teradataml DataFrame generated by the OutlierFilterFit() function.
+            Types: teradataml DataFrame
+
+        polynomialfeatures_fit_data:
+            Optional Argument.
+            Specifies the teradataml DataFrame generated by the PolynomialFeaturesFit() function.
+            Types: teradataml DataFrame
+
+        rownormalize_fit_data:
+            Optional Argument.
+            Specifies the teradataml DataFrame generated by the RowNormalizeFit() function.
+            Types: teradataml DataFrame
+
+        scale_fit_data:
+            Optional Argument.
+            Specifies the teradataml DataFrame generated by the ScaleFit() function.
+            Types: teradataml DataFrame
+
+        simpleimpute_fit_data:
+            Optional Argument.
+            Specifies the teradataml DataFrame generated by the SimpleImputeFit() function.
+            Types: teradataml DataFrame
+
+        fillrowid_column_name:
+            Optional Argument.
+            Specifies the name for the output column in which unique identifiers for each row are
+            populated.
+            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: 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 ColumnTransformer.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as ColumnTransformerObj.<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.
+        titanic = DataFrame.from_table("titanic")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Perform Bincode transformation and OneHotEncoding transformation using fit functions and
+        #             ColumnTransformer() function.
+        bin_code = BincodeFit(data=titanic,
+                              target_columns='age',
+                              method_type='Equal-Width',
+                              nbins=2,
+                              label_prefix='label_prefix')
+
+        one_hot_encoding = OneHotEncodingFit(data=titanic,
+                                             is_input_dense=True,
+                                             target_column="sex",
+                                             categorical_values=["male", "female"],
+                                             other_column="other")
+
+        ColumnTransformer_out = ColumnTransformer(fillrowid_column_name="output_value",
+                                                  input_data=titanic,
+                                                  bincode_fit_data=bin_code.output,
+                                                  onehotencoding_fit_data=one_hot_encoding.result)
+
+        # Print the result DataFrame.
+        print(ColumnTransformer_out.result)
+
+        # Example 2: Perform multiple NonLinearCombineFit transformation using fit function and
+        #            ColumnTransformer() function.
+        # Create multiple NonLinearCombineFit objects and pass those to ColumnTransformer.
+        NonLinearCombineFit_out1 = NonLinearCombineFit(data = titanic,
+                                                       target_columns = ["sibsp", "parch"],
+                                                       formula = "Y=(X0+X1+1)",
+                                                       result_column = "total_cost")
+
+        NonLinearCombineFit_out2 = NonLinearCombineFit(data = titanic,
+                                                       target_columns = [ "fare"],
+                                                       formula = "Y=(X0+1)",
+                                                       result_column = "total_fare_cost2")
+
+        NonLinearCombineFit_out3 = NonLinearCombineFit(data = titanic,
+                                                       target_columns = [ "fare"],
+                                                       formula = "Y=(X0+3)",
+                                                       result_column = "total_fare_cost3")
+
+        ColumnTransformer_out2 = ColumnTransformer(input_data=titanic,
+                                                   nonlinearcombine_fit_data=NonLinearCombineFit_out1.result,
+                                                   nonlinearcombine_fit_data_order_column=['parch'],
+                                                   nonlinearcombine_fit_data1=NonLinearCombineFit_out2.result,
+                                                   nonlinearcombine_fit_data1_order_column=['fare'],
+                                                   nonlinearcombine_fit_data2=NonLinearCombineFit_out3.result)
+
+        # Print the result DataFrame.
+        print(ColumnTransformer_out2.result)
+
+        # Example 3: Perform BincodeFit transformation along with OrdinalEncodingFit and
+        #            OneHotEncodingFit transformation using fit functions and ColumnTransformer()
+        #            function.
+        # Create BincodeFit object along with OrdinalEncodingFit and OneHotEncodingFit
+        # objects, and pass those to ColumnTransformer.
+        bin_code = BincodeFit(data=titanic,
+                              target_columns='age',
+                              method_type='Equal-Width',
+                              nbins=2,
+                              label_prefix='label_prefix')
+
+        one_hot_encoding = OneHotEncodingFit(data=titanic,
+                                              is_input_dense=True,
+                                              target_column="embarked",
+                                              categorical_values=["c", "s"],
+                                              other_column="other")
+
+        ordinal_encodingfit = OrdinalEncodingFit(target_column='sex', data=titanic)
+
+        ColumnTransformer_out3 = ColumnTransformer(fillrowid_column_name="output_value",
+                                                   input_data=titanic,
+                                                   bincode_fit_data=bin_code.output,
+                                                   onehotencoding_fit_data=one_hot_encoding.result,
+                                                   ordinalencoding_fit_data=ordinal_encodingfit.result)
+
+        # Print the result DataFrame.
+        print(ColumnTransformer_out3.result)
+    """

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

@@ -0,0 +1,113 @@
+def ConvertTo(data=None, target_columns=None, target_datatype=None, accumulate=None,
+              **generic_arguments):
+    """
+    DESCRIPTION:
+        The ConvertTo() function converts the specified input DataFrame columns to
+        specified data types.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        target_columns:
+            Required Argument.
+            Specifies the input teradataml DataFrame columns which needs to be
+            casted/converted to a different data type.
+            Types: str OR list of Strings (str)
+
+        target_datatype:
+            Required Argument.
+            Specifies target data type(s) into which "target_columns" need to be
+            converted. If one value is provided, it applies to all "target_columns".
+            If more than one value is specified, each "target_datatype" value applies to
+            corresponding "target_columns" value (in the order specified by the user).
+            Types: str OR list of Strings (str)
+
+        accumulate:
+            Optional Argument.
+            Specifies the name(s) of input teradataml DataFrame column(s) to
+            copy to the output. By default, the function copies all 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 SQL Engine function supports, else an
+                exception is raised.
+
+    RETURNS:
+        Instance of ConvertTo.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as ConvertToObj.<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 = DataFrame.from_table("titanic")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1 : Convert datatype of 'fare' to integer.
+        ConvertTo_out = ConvertTo(data = titanic,
+                                  target_columns = ["fare"],
+                                  target_datatype = ["integer"],
+                                  accumulate=['passenger', 'name', 'ticket']
+                                  )
+
+        # Print the result DataFrame.
+        print(ConvertTo_out.result)
+
+    """