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

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

@@ -0,0 +1,246 @@
+def SAX(data=None, data_filter_expr=None, window_type='GLOBAL', 
+        output_type='STRING', mean=None, std_dev=None, 
+        window_size=None, output_frequency=1, 
+        points_per_symbol=1, symbols_per_window=1, 
+        alphabet_size=4, bitmap_level=2, code_stats=0, 
+        breakpoints=None, 
+        output_fmt_index_style="NUMERICAL_SEQUENCE", 
+        **generic_arguments):
+    """
+    DESCRIPTION:
+        SAX() function uses Piecewise Aggregate Approximation (PAA) and 
+        transform a timeseries into sequence of symbols.
+        The symbols can be characters, string, and bitmap.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the time series whose value can be REAL or MULTIVAR_REAL.
+            Types: TDSeries
+
+        data_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data".
+            Types: ColumnExpression
+
+        window_type:
+            Optional Argument.
+            Specifies the window type used in the SAX transformation.
+            Default Value: GLOBAL
+            Permitted Values: GLOBAL, SLIDING
+            Types: str
+
+        output_type:
+            Optional Argument.
+            Specifies the output format of the result.
+            Default Value: STRING
+            Permitted Values: STRING, BITMAP, O_CHARS
+            Types: str
+
+        mean:
+            Optional Argument.
+            Specifies the global mean values that used to
+            calculate the SAX code for every partition.
+            Note:
+                * If "mean" not specified, the function calculates the mean values
+                  for every partition.
+                * If "mean" specifies a single value but there are multiple payloads,
+                  the specified value will apply to all payloads.
+                * If "mean" specifies multiple values, each value will be 
+                  applied to its corresponding payload.
+            Types: float, list of float
+
+        std_dev:
+            Optional Argument.
+            Specifies the global standard deviation values that used to
+            calculate the SAX code for every partition.
+            Note:
+                * If "std_dev" not specified, the function calculates the standard
+                  deviation values for every partition.
+                * If "std_dev" specifies a single value but there are multiple payloads,
+                  the specified value will apply to all payloads.
+                * If "std_dev" specifies multiple values, each value will be
+                  applied to its corresponding payload.
+            Types: float, list of float
+
+        window_size:
+            Optional Argument, Required if "window_type" is SLIDING.
+            Specifies the size of the window used in the SAX
+            transformation. Maximum value is 64000.
+            Types: int
+
+        output_frequency:
+            Optional Argument.
+            Specifies the number of data points that the window slides
+            between successive outputs.
+            Note:
+                * "output_frequency" is valid only for SLIDING "window_type".
+            Default Value: 1
+            Types: int
+
+        points_per_symbol:
+            Optional Argument.
+            Specifies the number of data points to be converted to one SAX
+            symbol.
+            Note:
+                * "points_per_symbol" is valid for GLOBAL "window_type".
+            Default Value: 1
+            Types: int
+
+        symbols_per_window:
+            Optional Argument.
+            Specifies the number of SAX symbols to be generated for each
+            window.
+            Note:
+                * "symbols_per_window" is valid for SLIDING "window_type".
+            Default Value: 1
+            Types: int
+
+        alphabet_size:
+            Optional Argument.
+            Specifies the number of symbols in the SAX alphabet. 
+            The alphabet consists of letters from 'a' to 't'.
+            The size of the alphabet must be less than or equal to 20 
+            and greater than or equal to 2.
+            Default Value: 4
+            Types: int
+
+        bitmap_level:
+            Optional Argument.
+            Specifies the level of the bitmap. The bitmap level
+            determines the number of consecutive symbols to be
+            converted to one symbol on a bitmap. 
+            "bitmap_level" must be greater than or equal to 1 and less than or equal to 4.
+            Default Value: 2
+            Types: int
+
+        code_stats:
+            Optional Argument.
+            Specifies whether to print the mean and standard deviation
+            Default Value: 0
+            Types: int
+
+        breakpoints:
+            Optional Argument.
+            Specifies the breakpoints to form the SAX code based on "data".
+            Types: float, list of float
+
+        output_fmt_index_style:
+            Optional Argument.
+            Specifies the index style of the output format.
+            Permitted Values: NUMERICAL_SEQUENCE
+            Default Value: NUMERICAL_SEQUENCE
+            Types: str
+
+        **generic_arguments:
+            Specifies the generic keyword arguments of UAF functions.
+            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.
+                    Note that, when UAF function is executed, an 
+                    analytic result table (ART) is created.
+                    Default Value: False
+                    Types: bool
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the
+                    function in a volatile ART or not. When set to
+                    True, results are stored in a volatile ART,
+                    otherwise not.
+                    Default Value: False
+                    Types: bool
+
+                output_table_name:
+                    Optional Argument.
+                    Specifies the name of the table to store results. 
+                    If not specified, a unique table name is internally 
+                    generated.
+                    Types: str
+
+                output_db_name:
+                    Optional Argument.
+                    Specifies the name of the database to create output 
+                    table into. If not specified, table is created into 
+                    database specified by the user at the time of context 
+                    creation or configuration parameter. Argument is ignored,
+                    if "output_table_name" is not specified.
+                    Types: str
+
+
+    RETURNS:
+        Instance of SAX.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as SAX_obj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            1. 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 UAF analytic functions.
+        display_analytic_functions(type="UAF")
+
+        # Import function SAX.
+        from teradataml import SAX
+
+        # Load the example data.
+        load_example_data("sax", ["finance_data4"])
+
+        # Create teradataml DataFrame object.
+        data = DataFrame.from_table("finance_data4")
+
+        # Create teradataml TDSeries object.
+        data_series_df = TDSeries(data=data,
+                                  id="id",
+                                  row_index="period",
+                                  row_index_style="SEQUENCE",
+                                  payload_field=["expenditure", "income", "investment"],
+                                  payload_content="MULTIVAR_REAL")
+
+        # Example 1: Execute SAX() function on the TDSeries to transform the
+        #            time series into sequence of symbols using GLOBAL window.
+        uaf_out = SAX(data=data_series_df, 
+                      window_type='GLOBAL', 
+                      output_type='STRING', 
+                      mean=[2045.16666, 2387.41666,759.083333], 
+                      std_dev=[256.612489,317.496587,113.352594], 
+                      output_frequency=1, 
+                      points_per_symbol=2,
+                      alphabet_size=10,
+                      code_stats=True)
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+
+        # Example 2: Execute SAX() function on the TDSeries to transform the
+        #            time series into sequence of symbols using SLIDING window.
+        uaf_out1 = SAX(data=data_series_df, 
+                       window_type='SLIDING', 
+                       window_size=4,
+                       symbols_per_window=5, 
+                       code_stats=True)
+
+        # Print the result DataFrame.
+        print(uaf_out1.result)
+    
+    """
+    

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

@@ -4,24 +4,31 @@ def SeasonalNormalize(data=None, data_filter_expr=None, season_cycle=None,
                       **generic_arguments):
     """
     DESCRIPTION:
-        The function SeasonalNormalize() takes a non-stationary series and
-        normalizes the series by removing the unit roots. The function can
-        be used with any cyclic data that can be subdivided into a collection
-        of logical periods, in which each period can be further subdivided
-        into a collection of logical intervals.
+        SeasonalNormalize() takes a non-stationary series and normalizes the
+        series by first dividing the series into cycles and intervals, then averaging
+        and normalizing with respect to each interval over all cycles.
+        This form of normalization is effective relative to eliminating
+        non-stationary properties such as unit roots and periodicities.
 
         The following procedure is an example of how to use SeasonalNormalize():
             1. Detect the unit roots using DickeyFuller().
-            2. Use DIFF() or SeasonalNormalize() to eliminate unit roots.
-            3. Use Unnormalize() to undo the effects of SeasonalNormalize(),
-               and compare it to the original series.
+            2. Use SeasonalNormalize() to create a series with potentially the unit roots eliminated.
+            3. Use DickeyFuller() to verify that unit roots were eliminated from the newly-formed normalized series.
+            4. Use ArimaEstimate() and ArimaValidate() to create an ARIMA model from the normalized series.
+            5. Use ArimaForecast() to forecast the normalized series.
+            6. Use Unnormalize() passing in the forecasted series and the original unnormalized series to
+               produce a forecasted series with the effects of SeasonalNormalize() removed.
 
 
     PARAMETERS:
         data:
             Required Argument.
-            Specifies a logical-runtime series, with real number
-            elements.
+            Single input source that contains univariate series instances.
+            The associated "payload_content" is 'REAL'.
+            The payload is the series element magnitude.
+            TDSeries must include the usage of the "interval" parameter
+            that is the interval to used by the function to divide the
+            series cycles into intervals.
             Types: TDSeries
 
         data_filter_expr:

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

@@ -16,7 +16,7 @@ def SignifPeriodicities(data=None, data_filter_expr=None,
         SignifPeriodicities():
             1. Use ArimaEstimate() to identify spectral candidates.
             2. Use ArimaValidate() to validate spectral candidates.
-            3. Use Plot() to plot the results.
+            3. Use DataFrame.plot() to plot the results.
             4. Compute the test statistic.
             5. Use SignifPeriodicities() on the periodicities of interest. 
                More than one periodicities can be entered using the 

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

@@ -161,7 +161,9 @@ def WhitesGeneral(data=None, data_filter_expr=None, variables_count=None,
                                   payload_field=["ACTUAL_VALUE","CALC_VALUE","RESIDUAL"],
                                   payload_content="MULTIVAR_REAL")
 
-        uaf_out1 = WhitesGeneral(data=data_series_df, variables_count=3, significance_level=0.05)
+        uaf_out1 = WhitesGeneral(data=data_series_df, 
+                                 variables_count=3, 
+                                 significance_level=0.05)
 
         # Print the result DataFrame.
         print(uaf_out1.result)

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

@@ -0,0 +1,368 @@
+def WindowDFFT(data=None, data_filter_expr=None, dfft_algorithm=None, 
+               dfft_zero_padding_ok=True, dfft_freq_style="K_INTEGRAL", 
+               dfft_hertz_sample_rate=None, dfft_human_readable=True, 
+               window_size_num=None, window_size_perc=None, 
+               window_overlap=0, window_is_symmetric=True, 
+               window_scale=None, window_type=None, 
+               window_exponential_center=None, 
+               window_exponential_tau=None, window_gaussian_std=None, 
+               window_general_cosine_coeff=None, 
+               window_general_gaussian_shape=None, 
+               window_general_gaussian_sigma=None, 
+               window_general_hamming_alpha=None, 
+               window_kaiser_beta=None, window_taylor_num_sidelobes=4, 
+               window_taylor_sidelobe_suppression=30, 
+               window_taylor_norm=True, window_tukey_alpha=None, 
+               output_fmt_content=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        WindowDFFT() function applies a user-selected window to data before 
+        processing it with DFFT(). Windows are used to remove 
+        noise or spectral leakage. The window type is determined 
+        for the specific use case based on signal frequency, 
+        amplitude, strength and so on.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the time series or spatial series.
+            Types: TDSeries, TDAnalyticResult
+
+        data_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data".
+            Types: ColumnExpression
+
+        dfft_algorithm:
+            Optional Argument.
+            Specifies the user-defined algorithm that bypasses the
+            internal DFFT planner, and influences the core DFFT
+            algorithm associated with the primary DFFT calculation.
+            Note:
+            * When "dfft_algorithm" is not passed, then the internal DFFT planner selects 
+              the most efficient algorithm for the operation.
+            Permitted Values: COOLEY_TUKEY, SINGLETON
+            Types: str
+
+        dfft_zero_padding_ok:
+            Optional Argument.
+            Specifies whether to add zeros to the end of a given
+            series to achieve a more efficient computation for the
+            Fast Fourier Transform coefficients.
+            Default Value: True
+            Types: bool
+
+        dfft_freq_style:
+            Optional Argument.
+            Specifies the format or values associated with the x-axis of the
+            output.
+            Permitted Values: 
+                * K_INTEGRAL: Integer representation.
+                * K_SAMPLE_RATE: Integer normalized to number entries, with ranges from -0.5 to +0.5.
+                * K_RADIANS: Radian ranges from -π to +π.
+                * K_HERTZ: Frequency in hertz. Must be used in conjunction with "dfft_hertz_sample_rate".
+            Default Value: K_INTEGRAL
+            Types: str
+
+        dfft_hertz_sample_rate:
+            Optional Argument.
+            Specifies the sample rate as a floating point constant, in
+            hertz. A value of 10000.0 indicates that the sample 
+            points were obtained by sampling at a rate of 10,000 
+            hertz.
+            Note:
+                * "dfft_hertz_sample_rate" is only valid with "dfft_freq_style".
+            Types: float
+
+        dfft_human_readable:
+            Optional Argument.
+            Specifies whether the produced output rows are in human-readable or raw form.
+            Human-readable output is symmetric around 0, such as -3, -2, -1, 0, 1, 2, 3 whereas
+            raw output is sequential, starting at zero, such as 0, 1, 2, 3.
+            Permitted Values:
+                * True: Human-readable output.
+                * False: Raw output.
+            Default Value: True
+            Types: bool
+
+        window_size_num:
+            Optional Argument.
+            Specifies the size of the window.
+            Note:
+               * "window_size_num" must be greater than zero.
+               * "window_size_num" and "window_size_perc" are mutually exclusive.
+            Types: int
+
+        window_size_perc:
+            Optional Argument.
+            Specifies the size of the window within a series as a percentage.
+            Note:
+               * "window_size_perc" must be greater than zero.
+               * "window_size_num" and "window_size_perc" are mutually exclusive.
+            Types: float
+
+        window_overlap:
+            Optional Argument.
+            Specifies the number of values by which the window slides down for 
+            each DFFT calculation within a series.
+            Note:
+                * The value must be less than the window size.
+                * To use fraction form, use "window_size_perc".
+            Default Value: 0
+            Types: int
+
+        window_is_symmetric:
+            Optional Argument.
+            Specifies whether to use a symmetric or periodic window.
+            Permitted Values:
+                * False: Periodic
+                * True: Symmetric
+            Default Value: True
+            Types: bool
+
+        window_scale:
+            Optional Argument.
+            Specifies the spectral density type applied to the result values.
+            Permitted Values: DENSITY, SPECTRUM
+            Types: str
+
+        window_type:
+            Optional Argument.
+            Specifies the type of window to use.
+            Note: 
+                * Some windows have additional options such as Taylor, in which case refer 
+                  to the Taylor parameter for specific Taylor window options.
+            Permitted Values: 
+                * BARTHANN
+                * BARTLETT, 
+                * BLACKMAN,               
+                * BLACKMANHARRIS, 
+                * BOHMAN, 
+                * BOXCAR, 
+                * COSINE, 
+                * EXPONENTIAL,
+                * FLATTOP,
+                * GAUSSIAN, 
+                * GENERAL_COSINE, 
+                * GENERAL_GAUSSIAN, 
+                * GENERAL_HAMMING, 
+                * HAMMING, HANN, 
+                * KAISER, 
+                * NUTTALL, 
+                * PARZEN, 
+                * TAYLOR, 
+                * TRIANG, 
+                * TUKEY
+            Types: str
+
+        window_exponential_center:
+            Optional Argument.
+            Specifies the center of the window. 
+            It is a parameter for "window_type" as EXPONENTIAL.
+            The default value is (windowSize - 1 ) / 2.
+            Types: float
+
+        window_exponential_tau:
+            Optional Argument.
+            Specifies the amount of window decay.
+            It is a parameter for window_type as EXPONENTIAL.
+            If the "window_exponential_center" is zero, then use ( windowSize - 1 ) / ln( x ) if x is the 
+            fractional part of the window remaining at the end of 
+            the window.
+            Types: float
+
+        window_gaussian_std:
+            Optional Argument. Required if "window_type" is GAUSSIAN.
+            Specifies the standard deviation of the Gaussian window.
+            Types: float
+
+        window_general_cosine_coeff:
+            Optional Argument. Required if "window_type" is GENERAL_GUASSIAN.
+            Specifies the list of weighing coefficients.
+            Types: float, list of float
+
+        window_general_gaussian_shape:
+            Optional Argument. Required if "window_type" is GENERAL_GUASSIAN.
+            specifies the gaussian shape. 
+            Types: float
+
+        window_general_gaussian_sigma:
+            Optional Argument. Required if "window_type" is GENERAL_GUASSIAN.
+            Specifies the standard deviation value.
+            Types: float
+
+        window_general_hamming_alpha:
+            Optional Argument. Required if "window_type" is GENERAL_HAMMING.
+            Specifies the value of the window coefficient.
+            Types: float
+
+        window_kaiser_beta:
+            Optional Argument. Required if "window_type" is KAISER.
+            Specifies the shape between the main lobe width and side
+            lobe level.
+            Types: float
+
+        window_taylor_num_sidelobes:
+            Optional Argument.
+            Specifies the number of nearly constant level sidelobes
+            adjacent to the main lobe.
+            Default Value: 4
+            Types: int
+
+        window_taylor_sidelobe_suppression:
+            Optional Argument.
+            Specifies the suppression level of the side lobe in decibels
+            relative to the DC gain of the main lobe.
+            Default Value: 30
+            Types: float
+
+        window_taylor_norm:
+            Optional Argument.
+            Specifies the normalization factor for the Taylor window.
+            Permitted Values:
+                * False: For an even sized window, divides the window by the 
+                         value that would occur between the two middle values.
+                * True : For an odd sized window, divides the window by the 
+                         largest (middle) value.
+            Default Value: True
+            Types: bool
+
+        window_tukey_alpha:
+            Optional Argument. Required if "window_type" is TUKEY.
+            Specifies the shape of the window inside the cosine-tapered region.
+            A value of 0 is a rectangular window and value of 1 is the same as a Hann window. 
+            Types: float
+
+        output_fmt_content:
+            Optional Argument.
+            Specifies how the Fourier coefficients should be output.
+            Permitted Values: 
+                * COMPLEX
+                * AMPL_PHASE_RADIANS
+                * AMPL_PHASE_DEGREES
+                * AMPL_PHASE
+                * MULTIVAR_COMPLEX
+                * MULTIVAR_AMPL_PHASE_RADIANS
+                * MULTIVAR_AMPL_PHASE_DEGREES
+                * MULTIVAR_AMPL_PHASE
+            Types: str
+            
+        **generic_arguments:
+            Specifies the generic keyword arguments of UAF functions.
+            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.
+                    Note that, when UAF function is executed, an 
+                    analytic result table (ART) is created.
+                    Default Value: False
+                    Types: bool
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the
+                    function in a volatile ART or not. When set to
+                    True, results are stored in a volatile ART,
+                    otherwise not.
+                    Default Value: False
+                    Types: bool
+
+                output_table_name:
+                    Optional Argument.
+                    Specifies the name of the table to store results. 
+                    If not specified, a unique table name is internally 
+                    generated.
+                    Types: str
+
+                output_db_name:
+                    Optional Argument.
+                    Specifies the name of the database to create output 
+                    table into. If not specified, table is created into 
+                    database specified by the user at the time of context 
+                    creation or configuration parameter. Argument is ignored,
+                    if "output_table_name" is not specified.
+                    Types: str
+
+
+    RETURNS:
+        Instance of WindowDFFT.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as WindowDFFT_obj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            1. 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 UAF analytic functions.
+        display_analytic_functions(type="UAF")
+
+        # Import function WindowDFFT.
+        from teradataml import WindowDFFT
+
+        # Load the example data.
+        load_example_data("uaf", ["windowdfft"])
+
+        # Create teradataml DataFrame object.
+        data = DataFrame.from_table("windowdfft")
+
+        # Create teradataml TDSeries object.
+        data_series_df = TDSeries(data=data,
+                                   id="id",
+                                   row_index="row_i",
+                                   row_index_style="SEQUENCE",
+                                   payload_field=["v2"],
+                                   payload_content="REAL")
+
+        # Example 1: Execute WindowDFFT() function to apply a window to the data before processing it with DFFT()
+        #            with window_type as BOHMAN and dfft_human_readable is True.
+        uaf_out = WindowDFFT(data=data_series_df,
+                             window_size_num=15,
+                             window_overlap=2,
+                             window_type="BOHMAN",
+                             window_is_symmetric=True,
+                             window_scale="SPECTRUM",
+                             dfft_algorithm="SINGLETON",
+                             dfft_zero_padding_ok=True,
+                             dfft_freq_style="K_INTEGRAL",
+                             dfft_human_readable=True)
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+
+        # Example 2: Execute WindowDFFT() function to apply a window to the data before processing it with DFFT()
+        #            with additional window parameters for window_type as GENERAL_COSINE and dfft_human_readable is False.
+        uaf_out1 = WindowDFFT(data=data_series_df,
+                              window_size_num=15,
+                              window_overlap=2,
+                              window_type="GENERAL_COSINE",
+                              window_general_cosine_coeff=[2.3,3.7],
+                              window_is_symmetric=True,
+                              window_scale="SPECTRUM",
+                              dfft_algorithm="SINGLETON",
+                              dfft_zero_padding_ok=True,
+                              dfft_freq_style="K_INTEGRAL",
+                              dfft_human_readable=False)
+
+        # Print the result DataFrame.
+        print(uaf_out1.result)
+
+    """
+