teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,333 @@
+def TDGLMPredict(object=None, newdata=None, id_column=None, accumulate=None, output_prob=False,
+                 output_responses=None, partition_column=None, family="GAUSSIAN",
+                 **generic_arguments):
+    """
+    DESCRIPTION:
+        The TDGLMPredict() function predicts target values (regression) and class labels
+        (classification) for test data using a model generated by the GLM().
+        Notes:
+            * Before using the features in the function, user must standardize the Input features
+                using ScaleFit() and ScaleTransform() functions.
+            * The function only accepts numeric features. Therefore, user must convert the categorical
+                features to numeric values before prediction.
+            * The function skips the rows with missing (null) values during prediction.
+            * User can use RegressionEvaluator(), ClassificationEvaluator(), or ROC() function as a
+                post-processing step for evaluating prediction results.
+            * The TDGLMPredict() function accepts models from GLM() function in SQLE.
+
+
+    PARAMETERS:
+        object:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the model data generated by GLM()
+            function or the instance of GLM.
+            Types: teradataml DataFrame or GLM
+
+        newdata:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the input data.
+            Types: teradataml DataFrame
+
+        id_column:
+            Required Argument.
+            Specifies the name of the column that uniquely identifies an
+            observation in the test data.
+            Types: str
+
+        accumulate:
+            Optional Argument.
+            Specifies the name(s) of input teradataml DataFrame column(s) to copy to the
+            output. By default, the function copies no input teradataml DataFrame columns
+            to the output.
+            Types: str OR list of Strings (str)
+
+        output_prob:
+            Optional Argument.
+            Specifies whether the function should output the probability for each
+            response.
+            Note:
+                Only applicable if the "family" is 'Binomial'.
+            Default Value: False
+            Types: bool
+
+        output_responses:
+            Optional Argument.
+            Specifies the class labels for which to output probabilities.
+            A label must be 0 or 1. If not specified, the function outputs the
+            probability of the predicted response.
+            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 
+            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 TDGLMPredict.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as TDGLMPredictObj.<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", "cal_housing_ex_raw")
+        
+        # Create teradataml DataFrame objects.
+        df=DataFrame.from_table("cal_housing_ex_raw")
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: This example takes raw housing data, and does the following
+        #            Uses ScaleFit() to standardize the data.
+        #            Uses ScaleTransform() to transform the data.
+        #            Uses GLM() to generate a model.
+        #            Uses TDGLMPredict() to predict target values.
+
+        # Scale "target_columns" with respect to 'STD' value of the column.
+        fit_obj = ScaleFit(data=df,
+                           target_columns=['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup',
+                           'Latitude', 'Longitude'],
+                           scale_method="STD")
+
+        # Scale values specified in the input data using the fit data generated by the Scale() function above.
+        obj = ScaleTransform(object=fit_obj.output,
+                             data=df,
+                             accumulate=["id","MedHouseVal"])
+
+        # Generate regression model using generalized linear model(GLM).
+        answer = GLM(input_columns=["MedInc", "HouseAge", "AveRooms", "AveBedrms", "Population", "AveOccup",
+                    "Latitude", "Longitude"],
+                    response_column="MedHouseVal",
+                    data=obj.result,
+                    nesterov=False)
+
+        # TDGLMPredict() predicts 'MedHouseVal' using generated regression model by GLM and newdata.
+        # Note that teradataml DataFrame representing the model is passed as input to "object".
+        TDGLMPredict_out = TDGLMPredict(newdata=obj.result,
+                                        object=answer.result,
+                                        accumulate="MedHouseVal",
+                                        id_column="id")
+
+        # Print the result DataFrame.
+        print(TDGLMPredict_out.result)
+
+        # Example 2: TDGLMPredict() predicts the 'MedHouseVal' using generated regression model
+        #            by GLM and newdata. Note that model is passed as instance of GLM to "object".
+        TDGLMPredict_out1 = TDGLMPredict(newdata=obj.result,
+                                         object=answer,
+                                         accumulate="MedHouseVal",
+                                         id_column="id")
+
+        # 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)
+    """

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

@@ -0,0 +1,189 @@
+def  TDNaiveBayesPredict(data = None, object = None, id_column = None,
+                         numeric_inputs = None, categorical_inputs = None,
+                         attribute_name_column = None, attribute_value_column = None,
+                         responses = None, output_prob = False, accumulate = None,
+                         **generic_arguments):
+    """
+    DESCRIPTION:
+        Function predicts classification label using model generated by NaiveBayes function
+        for a test set of data.
+    
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+        
+        object:
+            Required Argument.
+            Specifies the  teradataml DataFrame containing the model data
+            or instance of NaiveBayes.
+            Types: teradataml DataFrame or NaiveBayes
+        
+        id_column:
+            Required Argument.
+            Specifies the name of the column that uniquely identifies an 
+            observation in the "data".
+            Types: str
+        
+        numeric_inputs:
+            Optional Argument.
+            Specifies the name of the columns in "data" containing numeric attributes values.
+            Types: str OR list of Strings (str)
+        
+        categorical_inputs:
+            Optional Argument.
+            Specifies the name of the columns in "data" containing categorical attributes values.
+            Types: str OR list of Strings (str)
+        
+        attribute_name_column:
+            Optional Argument.
+            Specifies the name of the columns in "data" containing attributes names.
+            Types: str
+        
+        attribute_value_column:
+            Optional Argument.
+            Specifies the name of the columns in "data" containing attributes values.
+            Types: str
+        
+        responses:
+            Optional Argument.
+            Specifies a list of responses to output.
+            Types: str OR list of strs
+        
+        output_prob:
+            Optional Argument.
+            Specifies whether to output the probability for each response.
+            Default Value: False
+            Types: bool
+        
+        accumulate:
+            Optional Argument.
+            Specify the names of the columns in "data" that need to be copied 
+            from the input to output teradataml DataFrame.
+            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  NaiveBayesPredict.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as  NaiveBayesPredictObj.<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 
+        #        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("decisionforestpredict", ["housing_train", "housing_test"])
+        
+        # Create teradataml DataFrame objects.
+        housing_train = DataFrame.from_table("housing_train")
+        housing_test = DataFrame.from_table("housing_test")
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function  TDNaiveBayesPredict.
+        from teradataml import  TDNaiveBayesPredict, NaiveBayes, Unpivoting
+        
+        # Example 1: TDNaiveBayesPredict function to predict the classification label using Dense input.
+        NaiveBayes_out = NaiveBayes(data=housing_train, response_column='homestyle', 
+                                    numeric_inputs=['price','lotsize','bedrooms','bathrms','stories','garagepl'], 
+                                    categorical_inputs=['driveway','recroom','fullbase','gashw','airco','prefarea'])
+
+        NaiveBayesPredict_out = TDNaiveBayesPredict(data=housing_test, object=NaiveBayes_out.result, id_column='sn',
+                                                    numeric_inputs=['price','lotsize','bedrooms','bathrms','stories','garagepl'],
+                                                    categorical_inputs=['driveway','recroom','fullbase','gashw','airco','prefarea'],
+                                                    responses=['Classic', 'Eclectic', 'bungalow'],
+                                                    accumulate='homestyle',
+                                                    output_prob=True
+                                                    )
+        
+        # Print the result DataFrame.
+        print( NaiveBayesPredict_out.result)
+
+        # Example 2: TDNaiveBayesPredict function to predict the classification label using Sparse input.
+        
+        # Unpivoting the data for sparse input to naive bayes.
+        upvt_train = Unpivoting(data = housing_train, id_column = 'sn', 
+                                target_columns = ['price','lotsize','bedrooms','bathrms','stories','garagepl',
+                                                  'driveway','recroom','fullbase','gashw','airco','prefarea'],
+                                attribute_column = "AttributeName",
+                                value_column = "AttributeValue",
+                                accumulate = 'homestyle')
+
+        upvt_test = Unpivoting(data = housing_test, id_column = 'sn', 
+                               target_columns = ['price','lotsize','bedrooms','bathrms','stories','garagepl','driveway',
+                                                 'recroom','fullbase','gashw','airco','prefarea'],
+                               attribute_column = "AttributeName", value_column = "AttributeValue",
+                               accumulate = 'homestyle')
+
+        NaiveBayes_out1 = NaiveBayes(data=upvt_train.result, 
+                                     response_column='homestyle',
+                                     attribute_name_column='AttributeName', 
+                                     attribute_value_column='AttributeValue',
+                                     numeric_attributes=['price','lotsize','bedrooms','bathrms','stories','garagepl'], 
+                                     categorical_attributes=['driveway','recroom','fullbase','gashw','airco','prefarea'])
+
+        NaiveBayesPredict_out1 = TDNaiveBayesPredict(data=upvt_test.result, object=NaiveBayes_out1, id_column='sn',
+                                                     attribute_name_column='AttributeName',
+                                                     attribute_value_column='AttributeValue',
+                                                     responses=['Classic', 'Eclectic', 'bungalow'],
+                                                     accumulate='homestyle',
+                                                     output_prob=True
+                                                     )
+
+        # Print the result DataFrame.
+        print( NaiveBayesPredict_out1.result)
+    
+    """

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

@@ -0,0 +1,142 @@
+def TFIDF(data = None, doc_id_column = None, token_column = None,
+          tf_normalization = "NORMAL", idf_normalization = "LOG", 
+          regularization = "NONE", accumulate = None,
+          **generic_arguments):
+    
+    """
+    DESCRIPTION:
+        Function takes any document set and computes the Term Frequency (TF), 
+        Inverse Document Frequency (IDF), and Term Frequency Inverse Document 
+        Frequency (TF-IDF) scores for each term.
+    
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame that contains
+            the document id and the term.
+            Types: teradataml DataFrame
+        
+        doc_id_column:
+            Required Argument.
+            Specifies the name of the column in "data" that contains the 
+            document identifier.
+            Types: str
+        
+        token_column:
+            Required Argument.
+            Specifies the name of the column in "data" that contains the tokens.
+            Types: str
+        
+        tf_normalization:
+            Optional Argument.
+            Specifies the normalization method for calculating the term frequency (TF).
+            Default Value: "NORMAL"
+            Permitted Values: BOOL, COUNT, NORMAL, LOG, AUGMENT
+            Types: str
+        
+        idf_normalization:
+            Optional Argument.
+            Specifies the normalization method for calculating the inverse 
+            document frequency (IDF).
+            Default Value: "LOG"
+            Permitted Values: UNARY, LOG, LOGNORM, SMOOTH
+            Types: str
+        
+        regularization:
+            Optional Argument.
+            Specifies the regularization method for calculating the TF-IDF score. 
+            Default Value: "NONE"
+            Permitted Values: L2, L1, NONE
+            Types: str
+        
+        accumulate:
+            Optional Argument.
+            Specifies the name(s) of input teradataml DataFrame column(s) to copy 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 TFIDF.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as  TFIDFObj.<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 
+        #        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('naivebayestextclassifier',"token_table")
+        
+        # Create teradataml DataFrame objects.
+        inp = DataFrame.from_table('token_table')
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function  TFIDF.
+        from teradataml import  TFIDF
+        
+        # Example 1 : Compute the TF, IDF and TF-IDF scores
+        #             for each term in the input data.
+        TFIDF_out = TFIDF(data=inp, 
+                          doc_id_column='doc_id',
+                          token_column='token',
+                          tf_normalization = "LOG", 
+                          idf_normalization = "SMOOTH", 
+                          regularization = "L2",
+                          accumulate=['category'])
+        
+        # Print the result DataFrame.
+        print(TFIDF_out.result)
+    """