teradataml 20.0.0.8__py3-none-any.whl

teradataml/data/docs/sqle/docs_17_10/DecisionForestPredict.py

@@ -0,0 +1,139 @@
+def DecisionForestPredict(object=None, newdata=None, id_column=None, detailed=False,
+                          terms=None, output_prob=False, output_responses=None,
+                          **generic_arguments):
+    """
+    DESCRIPTION:
+        The DecisionForestPredict() function uses the model generated by the
+        DecisionForest() function to generate predictions on a response variable for a
+        test set of data.
+        The model can be stored in either a teradataml DataFrame or a DecisionForest object.
+
+    PARAMETERS:
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame which contains the model data generated by
+            the DecisionForest() function or instance of DecisionForest.
+            Types: teradataml DataFrame or DecisionForest
+
+        newdata:
+            Required Argument.
+            Specifies the name of the teradataml DataFrame containing the
+            attribute names and the values.
+            Types: teradataml DataFrame
+
+        id_column:
+            Required Argument.
+            Specifies a column containing a unique identifier for each test point
+            in the test set.
+            Types: str
+
+        detailed:
+            Optional Argument.
+            Specifies whether to output detailed information about the forest
+            trees; that is, the decision tree and the specific tree information,
+            including task index and tree index for each tree.
+            Default Value: False
+            Types: bool
+
+        terms:
+            Optional Argument.
+            Specifies the names of the newdata columns to copy to the output
+            teradataml DataFrame.
+            Types: str OR list of Strings (str)
+
+        output_prob:
+            Optional Argument.
+            Specifies whether to output probabilities.
+            Default Value: False
+            Types: bool
+
+        output_responses:
+            Optional Argument.
+            Specifies responses for which to output probabilities.
+            Types: str OR list of strs
+
+        **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 DecisionForestPredict.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as DecisionForestPredictObj.<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("decisionforestpredict", ["housing_train","housing_test"])
+
+        # Create teradataml DataFrame objects.
+        housing_test = DataFrame.from_table("housing_test")
+        housing_train = DataFrame.from_table("housing_train")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Train the data, i.e., create a decision forest Model with "tree_type" as classification.
+        formula = "homestyle ~ driveway + recroom + fullbase + gashw + airco + prefarea + price + lotsize + bedrooms + bathrms + stories + garagepl"
+        rft_model = DecisionForest(data=housing_train,
+                                   formula = formula,
+                                   tree_type="classification",
+                                   ntree=50,
+                                   tree_size=100,
+                                   nodesize=1,
+                                   variance=0.0,
+                                   max_depth=12,
+                                   maxnum_categorical=20,
+                                   mtry=3,
+                                   mtry_seed=100,
+                                   seed=100
+                                   )
+
+        # Run predict on the output of decision forest.
+        decision_forest_predict_out = DecisionForestPredict(object = rft_model,
+                                                            newdata = housing_test,
+                                                            id_column = "sn",
+                                                            detailed = False,
+                                                            terms = ["homestyle"]
+                                                            )
+
+        # Print the result DataFrame.
+        print(decision_forest_predict_out.result)
+
+    """

teradataml/data/docs/sqle/docs_17_10/DecisionTreePredict.py

@@ -0,0 +1,152 @@
+def DecisionTreePredict(object = None, newdata = None, attr_table_groupby_columns = None,
+                        attr_table_pid_columns = None, attr_table_val_column = None,
+                        output_response_probdist = False, accumulate = None,
+                        output_responses = None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The DecisionTreePredict() function applies a tree model to a data
+        input, outputting predicted labels for each data point.
+
+    PARAMETERS:
+        object:
+            Required Argument.
+            Specifies the name of the teradataml DataFrame containing the output
+            model from DecisionTree() function or instance of DecisionTree.
+            Types: teradataml DataFrame or DecisionTree
+
+        newdata:
+            Required Argument.
+            Specifies the name of the teradataml DataFrame containing the
+            attribute names and the values.
+            Types: teradataml DataFrame
+
+        attr_table_groupby_columns:
+            Required Argument.
+            Specifies the names of the columns on which newdata is
+            partitioned. Each partition contains one attribute of the input data.
+            Types: str OR list of Strings (str)
+
+        attr_table_pid_columns:
+            Required Argument.
+            Specifies the names of the columns that define the data point
+            identifiers.
+            Types: str OR list of Strings (str)
+
+        attr_table_val_column:
+            Required Argument.
+            Specifies the name of the column that contains the input values.
+            Types: str
+
+        output_response_probdist:
+            Optional Argument.
+            Specifies whether to output probabilities.
+            Note: "output_response_probdist" argument can accept input value True
+                  only when teradataml is connected to Vantage 1.0 Maintenance
+                  Update 2 version or later.
+            Default Value: False
+            Types: bool
+
+        accumulate:
+            Optional Argument.
+            Specifies the names of input_table columns to copy to the output
+            teradataml DataFrame.
+            Types: str OR list of Strings (str)
+
+        output_responses:
+            Optional Argument.
+            Required if output_response_probdist is True.
+            Specifies all responses in newdata.
+            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 table or not.
+                    When set to True, results are persisted in 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 volatile table or not.
+                    When set to True, results are stored in 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
+                SQLE Engine function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of DecisionTreePredict.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as DecisionTreePredictObj.<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 the Vantage user is connected to.
+        #    3. To check the list of analytic functions available on the Vantage user connected to,
+        #       use "display_analytic_functions()"
+
+        # Load the example data.
+        load_example_data("DecisionTreePredict", ["iris_attribute_train",
+        "iris_response_train", "iris_attribute_test"])
+
+        # Create teradataml DataFrame objects.
+        iris_attribute_test = DataFrame.from_table("iris_attribute_test")
+        iris_attribute_train = DataFrame.from_table("iris_attribute_train")
+        iris_response_train = DataFrame.from_table("iris_response_train")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Import function DecisionTreePredict.
+        from teradataml import DecisionTreePredict
+
+        # Example 1: First train the data, i.e., create a decision tree Model and then
+        #            run predict on the output of decision tree.
+        td_decision_tree_out  = DecisionTree(attribute_name_columns = 'attribute',
+                                             attribute_value_column = 'attrvalue',
+                                             id_columns = 'pid',
+                                             attribute_table = iris_attribute_train,
+                                             response_table = iris_response_train,
+                                             response_column = 'response',
+                                             approx_splits = False,
+                                             num_splits = 3,
+                                             nodesize = 10,
+                                             max_depth = 10,
+                                             weighted = False,
+                                             split_measure = "gini",
+                                             output_response_probdist = False)
+
+        # Run predict on the output of DecisionTree.
+        decision_tree_predict_out = DecisionTreePredict(newdata=iris_attribute_test,
+                                                        newdata_partition_column='pid',
+                                                        object=td_decision_tree_out,
+                                                        attr_table_groupby_columns='attribute',
+                                                        attr_table_pid_columns='pid',
+                                                        attr_table_val_column='attrvalue',
+                                                        accumulate='pid',
+                                                        output_response_probdist=False,
+                                                        output_responses=['pid','attribute'])
+
+        # Print output DataFrame.
+        print(decision_tree_predict_out.result)
+
+    """

teradataml/data/docs/sqle/docs_17_10/FTest.py

@@ -0,0 +1,161 @@
+def FTest(data = None, alpha = None,
+          first_sample_variance=None,
+          first_sample_column=None,
+          df1=None,
+          second_sample_variance=None,
+          second_sample_column=None,
+          df2=2,
+          alternate_hypothesis='two-tailed',
+          **generic_arguments):
+    """
+    DESCRIPTION:
+        The FTest() function performs an F-test, for which the test statistic follows an
+        F-distribution under the Null hypothesis.
+        Function compares the variances of two independent populations.
+        If the variances are significantly different, the FTest() function rejects the
+        Null hypothesis, indicating that the variances may not come from the same
+        underlying population.
+        Use the function to compare statistical models that have been fitted to a
+        data set, to identify the model that best fits the population from which the data
+        were sampled.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        alpha:
+            Optional Argument.
+            Specifies the probability of rejecting the null hypothesis when it is true
+            (value below which null hypothesis is rejected).
+            "alpha" must be a numeric value in the range [0, 1].
+            Default Value: 0.05
+            Types: float
+
+        first_sample_column:
+            Required if "first_sample_variance" is omitted, disallowed otherwise.
+            Specifies the name of the input column that contains the data for the
+            first sample population.
+            Types: str
+
+        first_sample_variance:
+            Required if "first_sample_column" is omitted, disallowed otherwise.
+            Specifies the variance of the first sample population.
+            Types: float
+
+        df1:
+            Required if "first_sample_column" is omitted, disallowed otherwise.
+            Specifies the degrees of freedom of the first sample.
+            Types: integer
+
+        second_sample_column:
+            Required if "second_sample_variance" is omitted, disallowed otherwise.
+            Specifies the name of the input column that contains the data for the
+            second sample population.
+            Types: str
+
+        second_sample_variance:
+            Required if "second_sample_column" is omitted, disallowed otherwise.
+            Specifies the variance of the second sample population.
+            Types: float
+
+        df2:
+            Required if "second_sample_column" is omitted, disallowed otherwise.
+            Specifies the degrees of freedom of the second sample.
+            Types: integer
+
+        alternate_hypothesis:
+            Optional Argument.
+            Specifies the alternative hypothesis.
+            Permitted Values:
+                * lower-tailed - Alternate hypothesis (H 1): μ < μ0.
+                * upper-tailed - Alternate hypothesis (H 1): μ > μ0.
+                * two-tailed - Rejection region is on two sides of sampling distribution
+                               of test statistic.
+                               Two-tailed test considers both lower and upper tails of
+                               distribution of test statistic.
+                               Alternate hypothesis (H 1): μ ≠ μ0
+            Default Value: two-tailed
+            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 table or
+                    not. When set to True, results are persisted in 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 volatile table
+                    or not. When set to True, results are stored in 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
+                SQLE Engine function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of FTest.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as FTestObj.<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: Run FTest() with first_sample_variance, second_sample_variance,
+        #            df1 and df2.
+        obj = FTest(data=titanic_data, alpha=0.5,
+                    second_sample_column="parch",
+                    alternate_hypothesis="two-tailed",
+                    first_sample_variance=5,
+                    second_sample_variance=8,
+                    df1=1, df2=2
+                    )
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+        # Example 2: Run FTest() with only required arguments.
+        obj = FTest(data=titanic_data,
+                    second_sample_column="parch",
+                    second_sample_variance=8,
+                    df2=2
+                    )
+
+        # Print the result DataFrame.
+        print(obj.result)
+    """

teradataml/data/docs/sqle/docs_17_10/FillRowId.py

@@ -0,0 +1,83 @@
+def FillRowId(data = None, row_id_column = None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The FillRowId() function adds a column of unique row identifiers to the
+        input DataFrame.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        row_id_column:
+            Optional Argument.
+            Specifies a name for the ID column in the output.
+            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 table or
+                    not. When set to True, results are persisted in 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 volatile table
+                    or not. When set to True, results are stored in 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
+                SQLE Engine function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of FillRowID.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as FillRowIDObj.<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: Add column "PassengerId" with unique row identifiers to the input
+        #          teradataml DataFrame.
+        obj = FillRowId(data=titanic_data,
+                        row_id_column='PassengerId'
+                       )
+
+        # Print the result DataFrame.
+        print(obj.result)
+    """

teradataml/data/docs/sqle/docs_17_10/Fit.py

@@ -0,0 +1,88 @@
+def Fit(data=None, object=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The Fit() function determines whether specified numeric transformations can be
+        applied to specified "target_columns" and outputs a DataFrame to use as input
+        "data" for Transform() function, which does the transformations.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        object:
+            Required Argument.
+            Specifies the transformation teradataml DataFrame that contains transformation
+            information for the columns in "data".
+            Types: teradataml DataFrame
+
+        **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 table or
+                    not. When set to True, results are persisted in 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 volatile table
+                    or not. When set to True, results are stored in 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
+                    SQLE Engine function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of Fit.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as FitObj.<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")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Run Fit() with all arguments.
+        fit_df = Fit(data=iris_input,
+                     object=transformation_df,
+                     object_order_column='TargetColumn'
+                    )
+
+        # Print the result DataFrame.
+        print(fit_df)
+
+    """