teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,225 @@
+def Shap(data = None, object = None, id_column=None, training_function = None,
+         model_type = "Regression", input_columns = None, detailed = False,
+         accumulate = None, num_parallel_trees = 1000, num_boost_rounds = 10,
+         **generic_arguments):
+
+    """
+    DESCRIPTION:
+        Function to get explanation for individual predictions 
+        (feature contributions) in a machine learning model based on the 
+        co-operative game theory optimal Shapley values.
+    
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the teradataml DataFrame.
+            Types: teradataml DataFrame
+        
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the model data.
+            Types: teradataml DataFrame
+
+        id_column:
+            Required Argument.
+            Specifies the input data column name that has the unique identifier
+            for each row in the "data".
+            Types: str
+        
+        training_function:
+            Required Argument.
+            Specifies the model type name.
+            Permitted Values: TD_GLM, TD_DECISIONFOREST, TD_XGBOOST
+            Types: str
+        
+        model_type:
+            Required Argument.
+            Specifies the operation to be performed on input data.
+            Default Value: "Regression"
+            Permitted Values: Regression, Classification
+            Types: str
+        
+        input_columns:
+            Required Argument.
+            Specifies the names of the columns in "data" used for 
+            training the model (predictors, features or independent variables).
+            Types: str OR list of Strings (str)
+        
+        detailed:
+            Optional Argument.
+            Specifies whether to output detailed shap information about the 
+            forest trees.
+            Note: 
+                * It is only supported for "TD_XGBOOST" and "TD_DECISIONFOREST" 
+                  training functions.
+            Default Value: False
+            Types: bool
+        
+        accumulate:
+            Optional Argument.
+            Specifies the names of the input columns to copy to the output teradataml DataFrame.
+            Types: str OR list of Strings (str)
+        
+        num_parallel_trees:
+            Optional Argument.
+            Specify the number of parallel boosted trees. Each boosted tree 
+            operates on a sample of data that fits in an AMPs memory.
+            Note:
+                * By default, "num_parallel_trees" is chosen equal to the number of AMPs with 
+                  data.
+            Default Value: 1000
+            Types: int
+        
+        num_boost_rounds:
+            Optional Argument.
+            Specifies the number of iterations to boost the weak classifiers. The 
+            iterations must be an int in the range [1, 100000].
+            Default Value: 10
+            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 Shap.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as ShapObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            1. output
+    
+    
+    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("byom", "iris_input")
+        load_example_data("teradataml", ["cal_housing_ex_raw"])
+        
+        # Create teradataml DataFrame objects.
+        iris_input = DataFrame("iris_input")
+        data_input = DataFrame.from_table("cal_housing_ex_raw")
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function Shap.
+        from teradataml import Shap, XGBoost, DecisionForest, SVM
+        
+        # Example 1: Shap for classification model.
+        XGBoost_out = XGBoost(data=iris_input,
+                              input_columns=['sepal_length', 'sepal_width', 'petal_length', 'petal_width'],
+                              response_column = 'species',
+                              model_type='Classification',
+                              iter_num=25)
+        
+        Shap_out = Shap(data=iris_input, 
+                        object=XGBoost_out.result, 
+                        id_column='id',
+                        training_function="TD_XGBOOST", 
+                        model_type="Classification",
+                        input_columns=['sepal_length', 'sepal_width', 'petal_length', 'petal_width'], 
+                        detailed=True)
+        # Print the result DataFrame.
+        print(Shap_out.output_data)
+
+        # Example 2: Shap for regression model.
+
+        from teradataml import ScaleFit, ScaleTransform
+
+        # Scale "target_columns" with respect to 'STD' value of the column.
+        fit_obj = ScaleFit(data=data_input,
+                           target_columns=['MedInc', 'HouseAge', 'AveRooms',
+                                            'AveBedrms', 'Population', 'AveOccup',
+                                            'Latitude', 'Longitude'],
+                           scale_method="STD")
+
+        # Transform the data.
+        transform_obj = ScaleTransform(data=data_input,
+                                       object=fit_obj.output,
+                                       accumulate=["id", "MedHouseVal"])
+        
+        decision_forest_out = DecisionForest(data=transform_obj.result,
+                                             input_columns=['MedInc', 'HouseAge', 'AveRooms',
+                                                            'AveBedrms', 'Population', 'AveOccup',
+                                                            'Latitude', 'Longitude'],
+                                             response_column="MedHouseVal",
+                                             model_type="Regression",
+                                             max_depth = 10
+                                             )
+        Shap_out2 = Shap(data=transform_obj.result, 
+                         object=decision_forest_out.result,
+                         id_column='id',
+                         training_function="TD_DECISIONFOREST",
+                         model_type="Regression",
+                         input_columns=['MedInc', 'HouseAge', 'AveRooms','AveBedrms', 'Population', 'AveOccup','Latitude', 'Longitude'],
+                         detailed=True)
+
+        # Print the result DataFrame.
+        print(Shap_out2.output_data)
+
+        # Example 3: Shap for GLM model.
+        from teradataml import GLM
+        GLM_out = GLM(data=transform_obj.result,
+                      input_columns=['MedInc', 'HouseAge', 'AveRooms',
+                                     'AveBedrms', 'Population', 'AveOccup',
+                                     'Latitude', 'Longitude'],
+                      response_column="MedHouseVal",
+                      family="GAUSSIAN")
+        
+        Shap_out3 = Shap(data=transform_obj.result, 
+                         object=GLM_out.result,
+                         id_column='id',
+                         training_function="TD_GLM",
+                         model_type="Regression",
+                         input_columns=['MedInc', 'HouseAge', 'AveRooms','AveBedrms', 'Population', 'AveOccup','Latitude', 'Longitude'],
+                         detailed=False)
+
+        # Print the result DataFrame.
+        print(Shap_out3.output_data)
+    """

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

@@ -0,0 +1,153 @@
+def Silhouette(data=None, accumulate=None, id_column=None, cluster_id_column=None, target_columns=None,
+               output_type="SCORE", **generic_arguments):
+    """
+    DESCRIPTION:
+        The Silhouette() function refers to a method of interpretation and validation of consistency within
+        clusters of data. The function determines how well the data is clustered among clusters.
+
+        The silhouette value determines the similarity of an object to its cluster (cohesion) compared to
+        other clusters (separation). The silhouette plot displays a measure of how close each point in one
+        cluster is to the points in the neighbouring clusters and thus provides a way to assess parameters
+        like the optimal number of clusters.
+
+        The silhouette scores and its definitions are as follows:
+            1: Data is appropriately clustered
+            -1: Data is not appropriately clustered
+            0: Datum is on the border of two natural clusters
+        Notes:
+            * The algorithm used in this function is of the order of N*N (where N is the number of rows). Hence,
+              expect the query to run significantly longer as the number of rows increases in the input data.
+            * This function requires the UTF8 client character set for UNICODE data.
+            * 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
+
+        accumulate:
+            Optional Argument.
+            Specifies the name(s) of input teradataml DataFrame column(s) to copy to the output.
+            Note:
+                Applicable only when "output_type" is set to 'SAMPLE_SCORES'.
+            Types: str OR list of Strings (str)
+
+        id_column:
+            Required Argument.
+            Specifies the column which is the unique identifier of input rows.
+            Types: str
+
+        cluster_id_column:
+            Required Argument.
+            Specifies the column containing assigned cluster IDs for input data points.
+            Types: str
+
+        target_columns:
+            Required Argument.
+            Specifies the columns/features to be used for calculating silhouette score.
+            Types: str OR list of Strings (str)
+
+        output_type:
+            Optional Argument.
+            Specifies the output type or format.
+            Permitted Values:
+                * SCORE: Outputs Average Silhouette Score,
+                * SAMPLE_SCORES: Outputs Silhouette Score for each input sample,
+                * CLUSTER_SCORES: Outputs Average Silhouette Score for each cluster.
+            Default Value: "SCORE"
+            Types: str
+
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept.
+            Below are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the function in a table or not.
+                    When set to True, results are persisted in a table; otherwise, results
+                    are garbage collected at the end of the session.
+                    Default Value: False
+                    Types: boolean
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the function in a volatile table or not.
+                    When set to True, results are stored in a volatile table, otherwise not.
+                    Default Value: False
+                    Types: boolean
+
+            Function allows the user to partition, hash, order or local order the input
+            data. These generic arguments are available for each argument that accepts
+            teradataml DataFrame as input and can be accessed as:
+                * "<input_data_arg_name>_partition_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if the underlying
+                SQL Engine function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of Silhouette.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as SilhouetteObj.<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", ["mobile_data"])
+
+        # Create teradataml DataFrame objects.
+        mobile_data = DataFrame.from_table("mobile_data")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Find the silhouette score for each input sample.
+        Silhouette_result1 = Silhouette(accumulate=['feature'],
+                                        id_column="row_id",
+                                        cluster_id_column="userid",
+                                        target_columns='"value"',
+                                        output_type="SAMPLE_SCORES",
+                                        data=mobile_data)
+
+        # Print the result DataFrame.
+        print(Silhouette_result1.result)
+
+        # Example 2: Find average silhouette score of all input samples.
+        Silhouette_result2 = Silhouette(id_column="row_id",
+                                        cluster_id_column="userid",
+                                        target_columns=['"value"'],
+                                        data=mobile_data,
+                                        output_type="SCORE")
+
+        # Print the result DataFrame.
+        print(Silhouette_result2.result)
+
+        # Example 3: Find average silhouette scores of input samples for each cluster.
+        Silhouette_result3 = Silhouette(id_column="row_id",
+                                        cluster_id_column="userid",
+                                        target_columns=['"value"'],
+                                        data=mobile_data,
+                                        output_type="CLUSTER_SCORES")
+
+        # Print the result DataFrame.
+        print(Silhouette_result3.result)
+
+    """

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

@@ -0,0 +1,116 @@
+def SimpleImputeFit(data=None, stats_columns=None, literals_columns=None, partition_column=None,
+                    stats=None, literals=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        SimpleImputeFit() function outputs values to substitute for missing
+        values in the input data. The output values are input to SimpleImputeTransform()
+        function, which makes the substitutions.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        stats_columns:
+            Optional Argument.
+            Specifies the name(s) of the column(s) in "data" for which to calculate
+            the statistics.
+            Types: str OR list of Strings (str)
+
+        literals_columns:
+            Optional Argument.
+            Specifies the name(s) of the column(s) in "data" for which to impute literals.
+            Types: str OR list of Strings (str)
+
+        partition_column:
+            Optional Argument.
+            Specifies the name(s) of the column(s) in "data" to partition on.
+            Types: str OR list of Strings (str)
+
+        stats:
+            Optional Argument.
+            Specifies the stats to compute on input teradataml DataFrame columns.
+            Permitted Values: MIN, MAX, MEAN, MEDIAN, MODE
+            Types: str OR list of Strings (str)
+
+        literals:
+            Optional Argument.
+            Specifies the literal value to impute on input teradataml DataFrame
+            columns.
+            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 SimpleImputeFit.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as SimpleImputeFitObj.<attribute_name>.
+        Output teradataml DataFrame attribute names are:
+            1. output
+            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.
+
+        # Load the example data.
+        load_example_data("teradataml", ["titanic"])
+
+        # Create teradataml DataFrame.
+        titanic = DataFrame.from_table("titanic")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Create stats for "fare" column and impute value "2"
+        #            in "pclass" column.
+        fit_obj = SimpleImputeFit(data=titanic,
+                                  stats_columns="fare",
+                                  literals_columns="pclass",
+                                  partition_column="sex",
+                                  stats="median",
+                                  literals="2")
+
+        # Print the result DataFrame.
+        print(fit_obj.output)
+        print(fit_obj.output_data)
+    """

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

@@ -0,0 +1,109 @@
+def SimpleImputeTransform(data=None, object=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        SimpleImputeTransform() function substitutes specified values for missing values
+        in the input data. The specified values is generated by SimpleImputeFit() function
+        output.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the output of SimpleImputeFit() function
+            or the instance of SimpleImputeFit.
+            Types: teradataml DataFrame or SimpleImputeFit
+
+        **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 SimpleImputeTransform.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as SimpleImputeTransformObj.<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.
+        titanic = DataFrame.from_table("titanic")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Fill missing values of "age" column with median value and
+        #            impute value "General" on "cabin" column.
+        fit_obj = SimpleImputeFit(data=titanic,
+                                  stats_columns="age",
+                                  literals_columns="cabin",
+                                  stats="median",
+                                  literals="General")
+
+        # Print the result DataFrame.
+        print(fit_obj.output)
+
+        # Impute the values for missing values.
+        # Note that teradataml DataFrame representing the model is passed as
+        # input to "object".
+        obj = SimpleImputeTransform(data=titanic,
+                                     object=fit_obj.output
+                                     )
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+        # Example 2: Impute the values for missing values. Note that model is passed
+        #            as instance of SimpleImputeFit to "object".
+        obj1 = SimpleImputeTransform(data=titanic,
+                                     object=fit_obj
+                                     )
+
+        # Print the result DataFrame.
+        print(obj1.result)
+    """