teradataml 20.0.0.1__py3-none-any.whl → 20.0.0.3__py3-none-any.whl

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)
+    """

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

@@ -1,4 +1,4 @@
-def TextParser(data=None, object=None, text_column=None, covert_to_lowercase=True, stem_tokens=False,
+def TextParser(data=None, object=None, text_column=None, convert_to_lowercase=True, stem_tokens=False,
                remove_stopwords=False, accumulate=None, delimiter=" \t\n\f\r",
                punctuation="!#$%&()*+,-./:;?@\^_`{|}~", token_col_name=None, **generic_arguments):
     """
@@ -38,7 +38,7 @@ def TextParser(data=None, object=None, text_column=None, covert_to_lowercase=Tru
             Specifies the name of the input data column whose contents are to be tokenized.
             Types: str
 
-        covert_to_lowercase:
+        convert_to_lowercase:
             Optional Argument.
             Specifies whether to convert the text in "text_column" to lowercase.
             Default Value: True
@@ -165,7 +165,7 @@ def TextParser(data=None, object=None, text_column=None, covert_to_lowercase=Tru
         # Example 2 : Convert words in "text_data" column into their root forms.
         TextParser_out = TextParser(data=complaints,
                                     text_column="text_data",
-                                    covert_to_lowercase=True,
+                                    convert_to_lowercase=True,
                                     stem_tokens=True)
 
         # Print the result DataFrame.

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

@@ -0,0 +1,216 @@
+def Unpivoting(data = None, id_column = None, target_columns = None,
+                alias_names = None, attribute_column = "AttributeName", value_column = "AttributeValue",
+                accumulate = None, include_nulls = False, input_types = False, output_varchar = False,
+                indexed_attribute = False, include_datatypes = False,
+                **generic_arguments):
+    
+    """
+    DESCRIPTION:
+        Function unpivots the data, that is, changes the data from
+        dense format to sparse format.
+    
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+        
+        id_column:
+            Required Argument.
+            Specifies the name of the column in "data" which contains the input data identifier.
+            Types: str
+        
+        target_columns:
+            Required Argument.
+            Specifies the name(s) of input teradataml DataFrame column(s) which contains the data for  
+            unpivoting.
+            Types: str OR list of Strings (str)
+
+            Optional Argument.
+            Specifies alternate names for the values in the 'attribute_column'.
+            Types: str OR list of strs
+
+        alias_names:
+            Optional Argument.
+            Specifies alternate names for the values in the 'attribute_column'. 
+            column.
+            Types: str OR list of strs
+        
+        attribute_column:
+            Optional Argument.
+            Specifies the name of the column in the output DataFrame, which holds the names of pivoted columns.
+            Default Value: "AttributeName"
+            Types: str
+        
+        value_column:
+            Optional Argument.
+            Specifies the name of the column in the output DataFrame, which holds the values of pivoted columns.
+            Default Value: "AttributeValue"
+            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)
+        
+        include_nulls:
+            Optional Argument.
+            Specifies whether or not to include nulls in the transformation.
+            Default Value: False
+            Types: bool
+        
+        input_types:
+            Optional Argument.
+            Specifies whether attribute values should be organized into multiple columns based on data type groups.
+            Note:
+                * 'input_types' argument cannot be used when output_varchar is set to True.
+            Default Value: False
+            Types: bool
+        
+        output_varchar:
+            Optional Argument.
+            Specifies whether to output the 'value_column' in varchar format regardless of its data type.
+            Note:
+                * 'output_varchar' argument cannot be used when input_types is set to True.
+            Default Value: False
+            Types: bool
+        
+        indexed_attribute:
+            Optional Argument.
+            Specifies whether to output the column indexes instead of column names in AttributeName column. 
+            When set to True, outputs the column indexes instead of column names.
+            Default Value: False
+            Types: bool
+        
+        include_datatypes:
+            Optional Argument.
+            Specifies whether to output the original datatype name. When set to True,
+            outputs the original datatype name.
+            Default Value: False
+            Types: bool
+
+        **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 Unpivoting.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as UnpivotingObj.<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('unpivot', 'unpivot_input')
+        
+        # Create teradataml DataFrame objects.
+        upvt_inp = DataFrame('unpivot_input')
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function  Unpivoting.
+        from teradataml import  Unpivoting
+        
+        # Example 1 : Unpivot the data.
+        upvt1 = Unpivoting(data = upvt_inp, 
+                           id_column = 'sn', 
+                           target_columns = 'city',
+                           accumulate = 'week',
+                           include_nulls = True)
+        
+        # Print the result DataFrame.
+        print( upvt1.result)
+
+        # Example 2 : Unpivot the data with alternate names for the values in
+        #             the AttributeName output column.
+        upvt2= Unpivoting(data = upvt_inp, 
+                          id_column = 'sn',
+                          target_columns = 'city',
+                          alias_names = 'city_us', 
+                          attribute_column = "Attribute", 
+                          value_column = "value",
+                          accumulate = 'week', 
+                          include_nulls = True)
+
+        # Print the result DataFrame.
+        print( upvt2.result)
+
+        # Example 3 : Unpivot the data with multiple target columns and output
+        #             data types.
+        upvt3 = Unpivoting(data = upvt_inp, 
+                           id_column = 'sn', 
+                           target_columns = ['city','pressure'],
+                           attribute_column = "Attribute", 
+                           value_column = "value",
+                           accumulate = 'week', 
+                           include_nulls = True,
+                           indexed_attribute = True, 
+                           include_datatypes = True)
+
+        # Print the result DataFrame.
+        print( upvt3.result)
+    
+        # Example 4 : Unpivot the data with multiple target columns and output
+        #             the input types.
+        upvt4 = Unpivoting(data = upvt_inp, 
+                           id_column = 'sn', 
+                           target_columns = ['city','temp'],
+                           accumulate = 'week', 
+                           include_nulls = True, 
+                           input_types = True)
+                        
+        # Print the result DataFrame.
+        print( upvt4.result)
+
+    """

teradataml/data/docs/tableoperator/docs_17_20/Image2Matrix.py

@@ -0,0 +1,118 @@
+def Image2Matrix(data=None,
+                 output='gray',
+                 **generic_arguments):
+    """
+    DESCRIPTION:
+        Image2Matrix() function converts an image to a matrix.
+        It converts JPEG or PNG images to matrixes with payload values being the pixel values.
+        Note:
+            * The image size cannot be greater than 16 MB.
+            * The image should not exceed 4,000,000 pixels.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the teradataml DataFrame which has image details.
+            Types: Teradataml DataFrame
+
+        output:
+            Optional Argument.
+            Specifies the type of output matrix.
+            Default: 'gray'
+            Permitted Values:
+                'gray': Converts the image to a grayscale matrix.
+                'rgb': Converts the image to a RGB matrix.
+            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 Analytic Database
+                function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of Image2Matrix.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as Image2Matrix.<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 UAF analytic functions available
+        #        on Vantage user connected to, use
+        #        "display_analytic_functions()".
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Import function Image2Matrix.
+        from teradataml import Image2Matrix
+        import teradataml
+
+        # Drop the image table if it is present.
+        try:
+            db_drop_table('imageTable')
+        except:
+            pass
+
+        # Create a table to store the image data.
+        execute_sql('CREATE TABLE imageTable(id INTEGER, image BLOB);')
+
+        # Load the image data into the fileContent variable.
+        file_dir = os.path.join(os.path.dirname(teradataml.__file__), "data")
+        with open(os.path.join(file_dir,'peppers.png'), mode='rb') as file:
+            fileContent = file.read()
+
+        # Insert the image data into the table.
+        sql = 'INSERT INTO imageTable VALUES(?, ?);'
+        parameters = (1, fileContent)
+        execute_sql(sql, parameters)
+
+        # Create a DataFrame for the image table.
+        imageTable = DataFrame('imageTable')
+
+        # Example 1: Convert the image to matrix with gray values.
+        image2matrix = Image2Matrix(data=imageTable.select(['id', 'image']), 
+                                    output='gray')
+
+        # Print the result DataFrame.
+        print(image2matrix.result)
+
+        # Example 2: Convert the image to matrix with rgb values.
+        image2matrix2 = Image2Matrix(data=imageTable.select(['id', 'image']), 
+                                     output='rgb')
+
+        # Print the result DataFrame.
+        print(image2matrix2.result)
+    """

teradataml/data/docs/uaf/docs_17_20/ACF.py

@@ -1,6 +1,6 @@
 def ACF(data=None, data_filter_expr=None, max_lags=None, 
         func_type=False, unbiased=False, demean=True, 
-        qstat=False, alpha=None, round_results=False, 
+        qstat=False, alpha=None,
         **generic_arguments):
     """
     DESCRIPTION:
@@ -96,15 +96,6 @@ def ACF(data=None, data_filter_expr=None, max_lags=None,
                 * The function does not return confidence intervals.
             Types: float
 
-        round_results:
-            Optional Argument.
-            Specifies whether rounding should be done or not.
-            When set to True, results in the output row are
-            rounded before inserting the rows into dataframe,
-            otherwise not.
-            Default Value: False
-            Types: bool
-
         **generic_arguments:
             Specifies the generic keyword arguments of UAF functions.
             Below are the generic keyword arguments:

teradataml/data/docs/uaf/docs_17_20/ArimaEstimate.py

@@ -312,7 +312,7 @@ def ArimaEstimate(data1=None, data1_filter_expr=None, data2=None,
         references, such as ArimaEstimate_obj.<attribute_name>.
         Output teradataml DataFrame attribute names are:
             1. result
-            2. fitmetadata - Available when "model_stats" is set to True, otherwise not.
+            2. fitmetadata - Available when "fit_metrics" is set to True, otherwise not.
             3. fitresiduals - Available when "residuals" is set to True, otherwise not.
             4. model
             5. valdata

teradataml/data/docs/uaf/docs_17_20/ArimaForecast.py

@@ -118,6 +118,9 @@ def ArimaForecast(data=None, data_filter_expr=None, forecast_periods=None,
                                   payload_field="magnitude",
                                   payload_content="REAL")
 
+        # Example 1: Forecast 2 periods based on the model fitted by ArimaEstimate.
+        #            As the fit_percentage is greater than or equal to 100,
+        #            output of ArimaEstimate is used for ArimaForecast.
         # Execute ArimaEstimate function.
         arima_estimate_op = ArimaEstimate(data1=data_series_df,
                                           nonseasonal_model_order=[2,0,0],
@@ -128,15 +131,42 @@ def ArimaForecast(data=None, data_filter_expr=None, forecast_periods=None,
                                           residuals=True,
                                           fit_percentage=100)
 
-        # Example 1: Forecast 2 periods based on the model fitted by ArimaEstimate.
-        #            As the fit_percentage is greater than or equal to 100,
-        #            output of ArimaEstimate is used for ArimaForecast.
-
         # Create teradataml TDAnalyticResult object over the result attribute of 'arima_estimate_op'
         data_art_df = TDAnalyticResult(data=arima_estimate_op.result)
 
-        uaf_out = ArimaForecast(data=data_art_df, forecast_periods=2)
+        uaf_out = ArimaForecast(data=data_art_df, 
+                                forecast_periods=2)
 
         # Print the result DataFrame.
         print(uaf_out.result)
+
+    # Example 2: Forecast 2 periods based on the model fitted by ArimaValidate.
+    #            As the fit_percentage is less than 100,
+    #            output of ArimaEstimate is used for ArimaValidate and 
+    #            output of ArimaValidate is used for ArimaForecast.
+    # Execute ArimaEstimate function.
+    arima_estimate_op = ArimaEstimate(data1=data_series_df,
+                                      nonseasonal_model_order=[2,0,0],
+                                      constant=False,
+                                      algorithm="MLE",
+                                      coeff_stats=True,
+                                      fit_metrics=True,
+                                      residuals=True,
+                                      fit_percentage=80)
+
+    # Create TDAnalyticResult object over the result attribute of 'arima_estimate_op'.
+    data_art_df = TDAnalyticResult(data=arima_estimate_op.result)
+
+    # Execute ArimaValidate function.
+    arima_validate_op = ArimaValidate(data=data_art_df,
+                                      fit_metrics=TRUE,
+                                      residuals=TRUE)
+
+    data_art_df1 = TDAnalyticResult(data=arima_validate_op.result)
+
+    uaf_out = ArimaForecast(data=data_art_df1, 
+                            forecast_periods=2)
+
+    # Print the result DataFrames.
+    print(uaf_out.result)
     """

teradataml/data/docs/uaf/docs_17_20/ArimaValidate.py

@@ -149,7 +149,9 @@ def ArimaValidate(data=None, data_filter_expr=None, fit_metrics=False,
         # Create teradataml TDAnalyticResult object over the result attribute of 'arima_estimate_op'.
         data_art_df = TDAnalyticResult(data=arima_estimate_op.result)
 
-        uaf_out = ArimaValidate(data=data_art_df, fit_metrics=True, residuals=True)
+        uaf_out = ArimaValidate(data=data_art_df, 
+                                fit_metrics=True, 
+                                residuals=True)
 
         # Print the result DataFrames.
         print(uaf_out.result)