teradataml 20.0.0.0__py3-none-any.whl → 20.0.0.2__py3-none-any.whl

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

@@ -1,5 +1,9 @@
 def ScaleFit(data=None, target_columns=None, scale_method=None, miss_value="KEEP",
-             global_scale=False, multiplier='1', intercept='0', **generic_arguments):
+             global_scale=False, multiplier='1', intercept='0',
+             parameter_data=None, attribute_data=None, partition_columns=None,
+             ignoreinvalid_locationscale=False, unused_attributes="UNSCALED",
+             attribute_name_column=None, attribute_value_column=None, target_attributes=None,
+             **generic_arguments):
     """
     DESCRIPTION:
         ScaleFit() function outputs statistics to input to ScaleTransform() function,
@@ -15,6 +19,9 @@ def ScaleFit(data=None, target_columns=None, scale_method=None, miss_value="KEEP
             Required Argument.
             Specifies the input teradataml DataFrame column(s) for which to output statistics.
             The columns must contain numeric data in the range (-1e\u00B3\u2070\u2078, 1e\u00B3\u2070\u2078).
+            Note:
+                * This argument cannot be used with "target_attributes", "attribute_name_column", 
+                 "attribute_value_column".
             Types: str OR list of Strings (str)
 
         scale_method:
@@ -124,6 +131,60 @@ def ScaleFit(data=None, target_columns=None, scale_method=None, miss_value="KEEP
             Default Value: "0"
             Types: str OR list of String (str)
 
+        parameter_data:
+            Optional Argument.
+            Specifies the input teradataml DataFrame containing the parameters.
+            Note:
+                * This is valid when "data_partition_column" is used.
+            Types: teradataml DataFrame
+        
+        attribute_data:
+            Optional Argument.
+            Specifies the input teradataml DataFrame containing the attributes.
+            Note:
+                * This is valid when "data_partition_column" is used.
+            Types: teradataml DataFrame
+        
+        partition_columns:
+            Optional Argument.
+            Specifies the column name in the "data" to partition the input.
+            Types: str OR list of Strings (str)
+        
+        ignoreinvalid_locationscale:
+            Optional Argument.
+            Specifies whether to ignore invalid values of location and scale parameters.
+            Default Value: False
+            Types: bool
+        
+        unused_attributes:
+            Optional Argument.
+            Specifies whether to emit out unused attributes of different partitions
+            as unscaled values or NULLs (for dense input).
+            Permitted Values: 'NULLIFY', 'UNSCALED'
+            Default Value: 'UNSCALED'
+            Types: str
+        
+        attribute_name_column:
+            Optional Argument.
+            Specifies the column name in the "attribute_data" which contains attribute names.
+            Note:
+                * This is required for sparse input.
+            Types: str
+        
+        attribute_value_column:
+            Optional Argument.
+            Specifies the column name in the "attribute_data" which contains attribute values.
+            Note:
+                * This is required for sparse input.
+            Types: str
+        
+        target_attributes:
+            Optional Argument.
+            Specifies the attributes for which scaling should be performed.
+            Note:
+                * This is required for sparse input.
+            Types: str OR list of Strings (str)
+
         **generic_arguments:
             Specifies the generic keyword arguments SQLE functions accept.
             Below are the generic keyword arguments:
@@ -174,9 +235,16 @@ def ScaleFit(data=None, target_columns=None, scale_method=None, miss_value="KEEP
 
         # Load the example data.
         load_example_data("teradataml", ["scale_housing"])
+        load_example_data('scale', ["scale_attributes", "scale_parameters",
+        "scale_input_partitioned", "scale_input_sparse","scale_input_part_sparse"])
 
         # Create teradataml DataFrame.
         scaling_house = DataFrame.from_table("scale_housing")
+        scale_attribute = DataFrame.from_table("scale_attributes")
+        scale_parameter = DataFrame.from_table("scale_parameters")
+        scale_inp_part = DataFrame.from_table("scale_input_partitioned")
+        scale_inp_sparse = DataFrame.from_table("scale_input_sparse")
+        scale_inp_part_sparse = DataFrame.from_table("scale_input_part_sparse")
 
         # Check the list of available analytic functions.
         display_analytic_functions()
@@ -194,4 +262,54 @@ def ScaleFit(data=None, target_columns=None, scale_method=None, miss_value="KEEP
         # Print the result DataFrame.
         print(fit_obj.output)
         print(fit_obj.output_data)
+
+        # Example 2: Create statistics to scale "fare" and "age" columns
+        #            with respect to maximum absolute value with partition column
+        #            for dense input.
+        fit_obj = ScaleFit(data=scale_inp_part,
+                           attribute_data=scale_attribute,
+                           parameter_data=scale_parameter,
+                           target_columns=['fare', 'age'],
+                           scale_method="maxabs",
+                           miss_value="zero",
+                           global_scale=False,
+                           data_partition_column='pid',
+                           attribute_data_partition_column='pid',
+                           parameter_data_partition_column='pid')
+
+        # Print the result DataFrame.
+        print(fit_obj.output)
+        print(fit_obj.output_data)
+
+        # Example 3: Create statistics to scale "fare" column with respect to
+        #            range for sparse input.
+        fit_obj = ScaleFit(data=scale_inp_sparse,
+                           target_attribute=['fare'],
+                           scale_method="range",
+                           miss_value="keep",
+                           global_scale=False,
+                           attribute_name_column='attribute_column',
+                           attribute_value_column='attribute_value')
+
+        # Print the result DataFrame.
+        print(fit_obj.output)
+        print(fit_obj.output_data)
+
+        # Example 4: Create statistics to scale "fare" column with respect to
+        #            maximum absolute value for sparse input with partition column.
+        fit_obj = ScaleFit(data=scale_inp_part_sparse,
+                            parameter_data=scale_parameter,
+                            attribute_data=scale_attribute,
+                            scale_method="maxabs",
+                            miss_value="zero",
+                            global_scale=False,
+                            attribute_name_column='attribute_column',
+                            attribute_value_column='attribute_value',
+                            data_partition_column='pid',
+                            attribute_data_partition_column='pid',
+                            parameter_data_partition_column='pid')
+
+        # Print the result DataFrame.
+        print(fit_obj.output)
+        print(fit_obj.output_data)
     """

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

@@ -1,4 +1,5 @@
-def ScaleTransform(data=None, object=None, accumulate=None, **generic_arguments):
+def ScaleTransform(data=None, object=None, accumulate=None, attribute_name_column=None,
+                   attribute_value_column=None, **generic_arguments):
     """
     DESCRIPTION:
         ScaleTransform() function scales specified columns in input data, using ScaleFit() function output.
@@ -21,6 +22,20 @@ def ScaleTransform(data=None, object=None, accumulate=None, **generic_arguments)
             Specifies the names of input teradataml DataFrame columns to copy to the output.
             Types: str OR list of Strings (str)
 
+        attribute_name_column:
+            Optional Argument.
+            Specifies the column name in the "attribute_data" which contains attribute names.
+            Note:
+                * This is required for sparse input.
+            Types: str
+        
+        attribute_value_column:
+            Optional Argument.
+            Specifies the column name in the "attribute_data" which contains attribute values.
+            Note:
+                * This is required for sparse input.
+            Types: str
+
         **generic_arguments:
             Specifies the generic keyword arguments SQLE functions accept.
             Below are the generic keyword arguments:
@@ -70,9 +85,16 @@ def ScaleTransform(data=None, object=None, accumulate=None, **generic_arguments)
 
         # Load the example data.
         load_example_data("teradataml", ["scale_housing"])
+        load_example_data('scale', ["scale_attributes", "scale_parameters",
+        "scale_input_partitioned", "scale_input_sparse","scale_input_part_sparse"])
 
         # Create teradataml DataFrame.
         scaling_house = DataFrame.from_table("scale_housing")
+        scale_attribute = DataFrame.from_table("scale_attributes")
+        scale_parameter = DataFrame.from_table("scale_parameters")
+        scale_inp_part = DataFrame.from_table("scale_input_partitioned")
+        scale_inp_sparse = DataFrame.from_table("scale_input_sparse")
+        scale_inp_part_sparse = DataFrame.from_table("scale_input_part_sparse")
 
         # Check the list of available analytic functions.
         display_analytic_functions()
@@ -107,4 +129,74 @@ def ScaleTransform(data=None, object=None, accumulate=None, **generic_arguments)
 
         # Print the result DataFrame.
         print(obj1.result)
+
+        # Example 3: Create statistics to scale "fare" and "age" columns with respect to
+        #            maximum absolute value for partitioned input.
+        fit_obj = ScaleFit(data=scale_inp_part,
+                           attribute_data=scale_attribute,
+                           parameter_data=scale_parameter,
+                           target_columns=['fare', 'age'],
+                           scale_method="maxabs",
+                           miss_value="zero",
+                           global_scale=False,
+                           data_partition_column='pid',
+                           attribute_data_partition_column='pid',
+                           parameter_data_partition_column='pid')
+
+        obj = ScaleTransform(data=scale_inp_part,
+                             object=fit_obj.output,
+                             accumulate=['pid','passenger'],
+                             data_partition_column='pid',
+                             object_partition_column='pid')
+        
+        # Print the result DataFrame.
+        print(obj.result)
+
+
+        # Example 4: Create statistics to scale "fare" column with respect to
+        #            range for sparse input.
+        fit_obj = ScaleFit(data=scale_inp_sparse,
+                           target_attribute=['fare'],
+                           scale_method="range",
+                           miss_value="keep",
+                           global_scale=False,
+                           attribute_name_column='attribute_column',
+                           attribute_value_column='attribute_value')
+
+        obj = ScaleTransform(data=scale_inp_sparse,
+                             object=fit_obj.output,
+                             accumulate=['passenger'],
+                             attribute_name_column='attribute_column',
+                             attribute_value_column='attribute_value'
+                     )
+        
+        # Print the result DataFrame.
+        print(obj.result)
+
+
+        # Example 5: Create statistics to scale "fare" column with respect to
+        #            maximum absolute value for sparse input with partition column.
+        fit_obj = ScaleFit(data=scale_inp_part_sparse,
+                           parameter_data=scale_parameter,
+                           attribute_data=scale_attribute,
+                           scale_method="maxabs",
+                           miss_value="zero",
+                           global_scale=False,
+                           attribute_name_column='attribute_column',
+                           attribute_value_column='attribute_value',
+                           data_partition_column='pid',
+                           attribute_data_partition_column='pid',
+                           parameter_data_partition_column='pid')
+
+        obj = ScaleTransform(data=scale_inp_part_sparse,
+                             object=fit_obj.output,
+                             accumulate=["passenger",'pid'],
+                             attribute_name_column='attribute_column',
+                             attribute_value_column='attribute_value',
+                             object_partition_column='pid',
+                             data_partition_column='pid')
+        
+        # Print the result DataFrame.
+        print(obj.result)
+
     """

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

@@ -0,0 +1,197 @@
+def Shap(data = None, object = None, training_function = "TD_GLM",
+         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
+        
+        training_function:
+            Required Argument.
+            Specifies the model type name.
+            Default Value: "TD_GLM"
+            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.
+            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)
+    """

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

@@ -1,5 +1,6 @@
 def TDGLMPredict(object=None, newdata=None, id_column=None, accumulate=None, output_prob=False,
-                 output_responses=None, **generic_arguments):
+                 output_responses=None, partition_column=None, family="GAUSSIAN",
+                 **generic_arguments):
     """
     DESCRIPTION:
         The TDGLMPredict() function predicts target values (regression) and class labels
@@ -57,6 +58,18 @@ def TDGLMPredict(object=None, newdata=None, id_column=None, accumulate=None, out
             Note:
                 Only applicable if "output_prob" is True.
             Types: str OR list of strs
+        
+        partition_column:
+            Optional Argument.
+            Specifies the column names of "data" on which to partition the input.
+            Types: str OR list of Strings (str)
+
+        family:
+            Optional Argument.
+            Specifies the distribution exponential family.
+            Permitted Values: 'GAUSSIAN', 'BINOMIAL'
+            Default Value: 'GAUSSIAN'
+            Types: str
 
         **generic_arguments:
             Specifies the generic keyword arguments SQLE functions accept. Below 
@@ -168,4 +181,153 @@ def TDGLMPredict(object=None, newdata=None, id_column=None, accumulate=None, out
 
         # Print the result DataFrame.
         print(TDGLMPredict_out1.result)
+
+        # Example 3 : TDGLMPredict() predicts the 'medv' using generated regression model by GLM
+        #             using stepwise regression algorithm.   
+        #             This example uses the boston dataset and scales the data.
+        #             Scaled data is used as input data to generate the GLM model and predict the target values.
+
+        # loading the example data
+        load_example_data("decisionforest", ["boston"])
+        load_example_data('glm', ['housing_train_segment', 'housing_train_parameter', 'housing_train_attribute'])
+
+        # Create teradataml DataFrame objects.
+        boston_df = DataFrame('boston')
+        housing_seg = DataFrame('housing_train_segment')
+        housing_parameter = DataFrame('housing_train_parameter')
+        housing_attribute = DataFrame('housing_train_attribute')
+
+        # scaling the data
+        # Scale "target_columns" with respect to 'STD' value of the column.
+        fit_obj = ScaleFit(data=boston_df,
+                        target_columns=['crim','zn','indus','chas','nox','rm','age','dis','rad','tax','ptratio','black','lstat',],
+                        scale_method="STD")
+
+        # Scale values specified in the input data using the fit data generated by the ScaleFit() function above.
+        obj = ScaleTransform(object=fit_obj.output,
+                            data=boston_df,
+                            accumulate=["id","medv"])
+
+        boston = obj.result
+
+        # Generate generalized linear model(GLM) using stepwise regression algorithm.
+        glm_1 = GLM(data=boston,
+                    input_columns=['indus','chas','nox','rm'],
+                    response_column='medv',
+                    family='GAUSSIAN',
+                    lambda1=0.02,
+                    alpha=0.33,
+                    batch_size=10,
+                    learning_rate='optimal',
+                    iter_max=36,
+                    iter_num_no_change=100,
+                    tolerance=0.0001,
+                    initial_eta=0.02,
+                    stepwise_direction='backward',
+                    max_steps_num=10)
+        
+        # Predict target values using generated regression model by GLM and newdata.
+        res = TDGLMPredict(id_column="id",
+                            newdata=boston,
+                            object=glm_1,
+                            accumulate='medv')
+        
+        # Print the result DataFrame.
+        print(res.result)
+
+        # Example 4 : TDGLMPredict() predicts the 'medv' using generated regression model by GLM
+        #             stepwise regression algorithm with initial_stepwise_columns.
+        glm_2 = GLM(data=boston,
+                    input_columns=['crim','zn','indus','chas','nox','rm','age','dis','rad','tax','ptratio','black','lstat'],
+                    response_column='medv',
+                    family='GAUSSIAN',
+                    lambda1=0.02,
+                    alpha=0.33,
+                    batch_size=10,
+                    learning_rate='optimal',
+                    iter_max=36,
+                    iter_num_no_change=100,
+                    tolerance=0.0001,
+                    initial_eta=0.02,
+                    stepwise_direction='bidirectional',
+                    max_steps_num=10,
+                    initial_stepwise_columns=['rad','tax']
+            )
+
+        # Predict target values using generated regression model by GLM and newdata.
+        res = TDGLMPredict(id_column="id",
+                            newdata=boston,
+                            object=glm_2,
+                            accumulate='medv')
+
+        # Print the result DataFrame.
+        print(res.result)
+
+        # Example 5 : TDGLMPredict() predicts the 'price' using generated regression model by GLM
+        #             using partition by key.
+        glm_3 = GLM(data=housing_seg,
+                    input_columns=['bedrooms', 'bathrms', 'stories', 'driveway', 'recroom', 'fullbase', 'gashw', 'airco'],
+                    response_column='price',
+                    family='GAUSSIAN',
+                    batch_size=10,
+                    iter_max=1000,
+                    data_partition_column='partition_id'
+            )
+
+        # Predict target values using generated regression model by GLM and newdata.
+        res = TDGLMPredict(id_column="sn",
+                            newdata=housing_seg,
+                            object=glm_3,
+                            accumulate='price',
+                            newdata_partition_column='partition_id',
+                            object_partition_column='partition_id')
+        
+        # Print the result DataFrame.
+        print(res.result)
+
+        # Example 6 : TDGLMPredict() predicts the 'price' using generated regression model by GLM
+        #             using partition by key with attribute data.
+        glm_4 = GLM(data=housing_seg,
+                    input_columns=['bedrooms', 'bathrms', 'stories', 'driveway', 'recroom', 'fullbase', 'gashw', 'airco'],
+                    response_column='price',
+                    family='GAUSSIAN',
+                    batch_size=10,
+                    iter_max=1000,
+                    data_partition_column='partition_id',
+                    attribute_data = housing_attribute,
+                    attribute_data_partition_column = 'partition_id'
+            )
+
+        # Predict target values using generated regression model by GLM and newdata.
+        res = TDGLMPredict(id_column="sn",
+                newdata=housing_seg,
+                object=glm_4,
+                accumulate='price',
+                newdata_partition_column='partition_id',
+                object_partition_column='partition_id')
+        
+        # Print the result DataFrame.
+        print(res.result)
+
+        # Example 7 : TDGLMPredict() predicts the 'homestyle' using generated generalized linear model by GLM
+        #             using partition by key with parameter data.
+        glm_5 = GLM(data=housing_seg,
+                    input_columns=['bedrooms', 'bathrms', 'stories', 'driveway', 'recroom', 'fullbase', 'gashw', 'airco'],
+                    response_column='homestyle',
+                    family='binomial',
+                    iter_max=1000,
+                    data_partition_column='partition_id',
+                    parameter_data = housing_parameter,
+                    parameter_data_partition_column = 'partition_id'
+            )
+
+        res = TDGLMPredict(id_column="sn",
+                            newdata=housing_seg,
+                            object=glm_5,
+                            accumulate='homestyle',
+                            newdata_partition_column='partition_id',
+                            object_partition_column='partition_id')
+        
+        # Print the result DataFrame.
+        print(res.result)
     """