teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,171 @@
+def UNDIFF(data1=None, data1_filter_expr=None, data2=None,
+           data2_filter_expr=None, lag=None, differences=None,
+           seasonal_multiplier=None, initial_values=None,
+           input_fmt_input_mode=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The UNDIFF() function is the reverse of the DIFF() function.
+        It takes in a previously differenced series processed by DIFF(),
+        and produces the original series that existed prior to the differencing.
+
+    PARAMETERS:
+        data1:
+            Required Argument.
+            Specifies the differenced series or TDAnalyticResult
+            object created on the output of DIFF() function.
+            Types: TDSeries, TDAnalyticResult
+
+        data1_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data1".
+            Types: ColumnExpression
+
+        data2:
+            Optional Argument.
+            Specifies the original series.
+            This series is needed to reconstruct the series completely.
+            If the series was differenced with a lag of 1, then the initial
+            value of the original series must be present for a full
+            reconstruction. With a lag of 2, the initial 2 values must be present,
+            and so on. If the series was differenced multiple times, then the
+            initial values of the intermediate steps must be given.
+            Types: TDSeries
+
+        data2_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data2".
+            Types: ColumnExpression
+
+        lag:
+            Required Argument.
+            Specifies the lag between series elements.
+            Value must be greater than or equal to 0.
+            Types: int
+
+        differences:
+            Required Argument.
+            Specifies the difference between time series elements Yt and Yt-lag.
+            Value must be greater than or equal to 0.
+            Types: int
+
+        seasonal_multiplier:
+            Required Argument.
+            Specifies whether time series is seasonal.
+            When set to 0, indicates time series is nonseasonal,
+            otherwise indicates seasonal time series.
+            Value must be greater than or equal to 0.
+            Types: int
+
+        initial_values:
+            Optional Argument.
+            Specifies the starting values for the undifferencing operation.
+            Types: int, list of int, float OR list of float
+
+        input_fmt_input_mode:
+            Optional Argument.
+            Specifies the input mode supported by the function.
+            Permitted Values: MANY2ONE, ONE2ONE, MATCH
+            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 UNDIFF.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as UNDIFF_obj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            1. 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.
+
+        # Check the list of available UAF analytic functions.
+        display_analytic_functions(type="UAF")
+
+        # Load the example data.
+        load_example_data("uaf", ["ocean_buoy2"])
+
+        # Create teradataml DataFrame objects.
+        data = DataFrame.from_table("ocean_buoy2")
+
+        # Create teradataml TDSeries object.
+        data_series = TDSeries(data=data,
+                               id="buoy_id",
+                               row_index="n_seq_no",
+                               row_index_style= "SEQUENCE",
+                               payload_field="magnitude1",
+                               payload_content="REAL")
+
+        # Transform time series into a differenced time series.
+        uaf_out_1 = DIFF(data=data_series,
+                         lag=1,
+                         differences=1,
+                         seasonal_multiplier=0)
+
+        # Example 1 : Retrieve the original series that existed prior to the differencing
+        #             by taking the differenced series processed by DIFF() as input.
+
+        # Create teradataml TDSeries over the output generated from DIFF.
+        data_series_1 = TDSeries(data=uaf_out_1.result,
+                                 id="buoy_id",
+                                 row_index="ROW_I",
+                                 row_index_style= "SEQUENCE",
+                                 payload_field="OUT_magnitude1",
+                                 payload_content="REAL")
+
+        uaf_out = UNDIFF(data1=data_series_1,
+                         data2=data_series,
+                         lag=1,
+                         differences=1,
+                         seasonal_multiplier=0,
+                         input_fmt_input_mode="MATCH")
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+    """

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

@@ -0,0 +1,202 @@
+def Unnormalize(data1=None, data1_filter_expr=None, data2=None, 
+                data2_filter_expr=None, fields=None, 
+                input_fmt_input_mode=None, 
+                output_fmt_index_style="NUMERICAL_SEQUENCE", 
+                **generic_arguments):
+    """
+    DESCRIPTION:
+        The Unnormalize() function reconstructs a series created by SeasonalNormalize().
+        The function is usually used for the forecasting phase of modeling.
+
+        The following procedure is an example of how to use function when the series
+        to be modeled is found to be unstationary:
+            * Use SeasonalNormalize() to make the series stationary.
+            * Develop the ARIMA forecast model.
+            * Use the ARIMA model to forecast the normalized series.
+            * Use function on the forecasted normalized series to undo the
+              effects of normalization and produce the final forecasted series result.
+
+
+    PARAMETERS:
+        data1:
+            Required Argument.
+            Specifies the input series to unnormalize.
+            Input payload content type can be REAL, MUTLIVAR_REAL, or
+            MUTLTIVAR_ANYTYPE. TDSeries must include "interval" argument.
+            Types: TDSeries
+
+        data1_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data1".
+            Types: ColumnExpression
+
+        data2:
+            Required Argument.
+            Specifies the output series. Output series type matches input series type.
+            This should be a metadata output of SeasonalNormalize() function or
+            TDAnalyticResults created on the teradataml dataframe that contains
+            previously normalized results with the (mean, standardDeviation) pairs
+            needed to unnormalize the first input series.
+            Types: TDSeries, TDAnalyticResult
+
+        data2_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data2".
+            Types: ColumnExpression
+
+        fields:
+            Optional Argument.
+            Specifies fields to unnormalize. The fields should be separated by commas.
+            When specified, only the specified payload fields in the list are unnormalized,
+            otherwise all payload fields of the first input are unnormalized.
+            Values should be 0 or positive numbers. The payload field indices start
+            at 1.
+            Types: int
+
+        input_fmt_input_mode:
+            Required Argument.
+            Specifies the input mode supported by the function.
+            Permitted Values: MANY2ONE, ONE2ONE, MATCH
+            Types: str
+
+        output_fmt_index_style:
+            Optional Argument.
+            Specifies the INDEX_STYLE of the output format.
+            Permitted Values: NUMERICAL_SEQUENCE, FLOW_THROUGH
+            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 Unnormalize.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as Unnormalize_obj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            1. 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.
+
+        # Check the list of available UAF analytic functions.
+        display_analytic_functions(type="UAF")
+
+        # Load the example data.
+        load_example_data("uaf", ["store_sales"])
+
+        # Create teradataml DataFrame objects.
+        df = DataFrame("store_sales")
+
+        # Create teradataml TDSeries objects.
+        td_series = TDSeries(data=df,
+                             row_index="ts",
+                             row_index_style="TIMECODE",
+                             id="StoreID",
+                             payload_field="Sales",
+                             payload_content="REAL",
+                             interval="CAL_MONTHS(1)"
+                             )
+
+        # Produce the stationary series.
+        seasonalnormalize = SeasonalNormalize(data=td_series,
+                                              season_cycle="CAL_YEARS",
+                                              cycle_duration=1,
+                                              output_fmt_index_style="FLOW_THROUGH"
+                                              )
+
+        # Create teradataml TDSeries objects.
+        td_series1 = TDSeries(data=seasonalnormalize.result,
+                              id="StoreID",
+                              row_index="ROW_I",
+                              row_index_style="TIMECODE",
+                              payload_field="Sales",
+                              payload_content="REAL",
+                              interval="CAL_MONTHS(1)"
+                              )
+
+        # Example 1 : Function reverse the effects of normalization and
+        #             produce the final forecasted series result using TDSeries.
+
+        # Create teradataml TDSeries objects.
+        td_series2 = TDSeries(data=seasonalnormalize.metadata,
+                              id="StoreID",
+                              row_index="ROW_I",
+                              row_index_style="SEQUENCE",
+                              payload_field=["MEAN_Sales", "SD_Sales"],
+                              payload_content="MULTIVAR_REAL"
+                              )
+
+        uaf_out = Unnormalize(data1=td_series1,
+                              data2=td_series2,
+                              input_fmt_input_mode="MATCH",
+                              output_fmt_index_style="FLOW_THROUGH")
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+
+        # Example 2 : Function reverse the effects of normalization and
+        #             produce the final forecasted series result using TDAnalyticResult.
+
+        # Create teradataml TDAnalyticResult objects.
+        td_art = TDAnalyticResult(data=seasonalnormalize.result,
+                                  layer='ARTMETADATA')
+
+        uaf_out = Unnormalize(data1=td_series1,
+                              data2=td_art,
+                              input_fmt_input_mode="MATCH",
+                              output_fmt_index_style="FLOW_THROUGH")
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+    
+    """
+    

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

@@ -0,0 +1,171 @@
+def WhitesGeneral(data=None, data_filter_expr=None, variables_count=None,
+                  significance_level=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The WhitesGeneral() function checks for the presence of correlation
+        among the residual terms after running a regression. The function
+        determines if there exists any heteroscedastic variance in the
+        residuals of regression tests.
+        The output specifies the following:
+            * 'ACCEPT' means the null hypothesis is accepted,
+              and there is homoscedasticity variance evident.
+            * 'REJECT' means the null hypothesis is rejected,
+              and there is evidence of heteroscedasticity.
+
+       The Whites-General test does not require reordering like
+       the Goldfeld-Quandt test, and is not sensitive to the normal
+       distribution assumption like the Breusch-Pagan-Godfrey test.
+
+       The following procedure is an example of how to use WhitesGeneral() function:
+            1. Use the function MultivarRegr() for regression testing.
+            2. Use WhitesGeneral() on the residual output from MultivarRegr().
+            3. Determine if the variance is homoscedastic or heteroscedastic
+               from the WhitesGeneral() result.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the residual multivariate series or TDAnalyticResult
+            object over the residual output of UAF regression functions.
+            Input payload content is 'MULTIVAR_REAL'.
+            Types: TDSeries, TDAnalyticResult
+
+        data_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data".
+            Types: ColumnExpression
+
+        variables_count:
+            Required Argument.
+            Specifies the number of explanatory variables used
+            in the auxiliary regression in the payload of the
+            original series.
+            Types: int
+
+        significance_level:
+            Required Argument.
+            Specifies the significance level used for the test.
+            Types: float
+
+        **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 WhitesGeneral.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as WhitesGeneral_obj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            1. 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.
+
+        # Check the list of available UAF analytic functions.
+        display_analytic_functions(type="UAF")
+
+        # Load the example data.
+        load_example_data("uaf", ["house_values"])
+
+        # Create teradataml DataFrame object.
+        df = DataFrame.from_table("house_values")
+
+        # Create teradataml TDSeries object.
+        data_series_df = TDSeries(data=df,
+                                  id="cityid",
+                                  row_index="TD_TIMECODE",
+                                  payload_field=["house_val","salary","mortgage"],
+                                  payload_content="MULTIVAR_REAL")
+
+        # Execute multivariate regression function to identify the degree of
+        # linearity the explanatory variable and multiple response variables.
+        # Generate the model statistics and residual data as well.
+        multivar_out = MultivarRegr(data=data_series_df,
+                                    variables_count=3,
+                                    weights=False,
+                                    formula="Y = B0 + B1*X1 + B2*X2",
+                                    algorithm='QR',
+                                    coeff_stats=True,
+                                    model_stats=True,
+                                    residuals=True)
+
+        # Example 1: Perform Whites-General test on TDAnalyticResult object
+        #            over the result attribute of the "multivar_out" as input.
+        # Create teradataml TDAnalyticResult object over the 'result'
+        # attribute of the 'multivar_out'.
+        data_art_df = TDAnalyticResult(data=multivar_out.result)
+
+        uaf_out = WhitesGeneral(data=data_art_df,
+                                variables_count=3,
+                                significance_level=0.05)
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+
+        # Example 2: Perform Whites-General test on TDSeries
+        #            object over the 'fitresiduals' attribute
+        #            of the 'multivar_out'.
+        # Create teradataml TDSeries object over the 'fitresiduals' attribute
+        # of the 'multivar_out'.
+        data_series_df = TDSeries(data=multivar_out.fitresiduals,
+                                  id="cityid",
+                                  row_index="ROW_I",
+                                  row_index_style="SEQUENCE",
+                                  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)
+
+        # Print the result DataFrame.
+        print(uaf_out1.result)
+
+    """