teradataml 20.0.0.8__py3-none-any.whl

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

@@ -0,0 +1,173 @@
+def SeasonalNormalize(data=None, data_filter_expr=None, season_cycle=None,
+                      cycle_duration=None, season_info=0,
+                      output_fmt_index_style="NUMERICAL_SEQUENCE",
+                      **generic_arguments):
+    """
+    DESCRIPTION:
+        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 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.
+            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:
+            Optional Argument.
+            Specifies the filter expression for "data".
+            Types: ColumnExpression
+
+        season_cycle:
+            Required Argument.
+            Specifies the logical time-unit.
+            Permitted Values:
+                * CAL_YEARS
+                * CAL_MONTHS
+                * CAL_DAYS
+                * WEEKS
+                * DAYS
+                * HOURS
+                * MINUTES
+                * SECONDS
+                * MILLISECONDS
+                * MICROSECONDS
+            Types: str
+
+        cycle_duration:
+            Required Argument.
+            Specifies the number of time-units as the duration of each seasonal
+            cycle.
+            Types: int
+
+        season_info:
+            Optional Argument.
+            Specifies whether to generate additional columns CYCLE_NO and
+            SEASON_NO. CYCLE_NO is the n-th cycle of the season. SEASON_NO
+            is the season for the data.
+            Permitted Values:
+                * 0 indicates no extra columns being generated.
+                * 1 indicates SEASON_NO column being generated.
+                * 2 indicates CYCLE_NO column being generated.
+                * 3 indicates both SEASON_NO and CYCLE_NO columns being generated.
+            Default Value: 0
+            Types: int
+
+        output_fmt_index_style:
+            Optional Argument.
+            Specifies the index style of the output format.
+            Default Value: NUMERICAL_SEQUENCE
+            Permitted Values:
+                * NUMERICAL_SEQUENCE
+                * FLOW_THROUGH
+            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 SeasonalNormalize.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as SeasonalNormalize_obj.<attribute_name>.
+        Output teradataml DataFrame attribute names are:
+            1. result
+            2. metadata
+
+
+    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", ["river_data"])
+
+        # Create teradataml DataFrame object.
+        data = DataFrame.from_table("river_data")
+
+        # Create teradataml TDSeries object.
+        data_series_df = TDSeries(data=data,
+                                  id="station_id",
+                                  row_index="timevalue",
+                                  row_index_style="TIMECODE",
+                                  payload_field="flow_velocity",
+                                  payload_content="REAL",
+                                  interval="CAL_MONTHS(1)")
+
+        # Example 1 : Normalize the series by removing the unit roots.
+        uaf_out = SeasonalNormalize(data=data_series_df,
+                                    season_cycle="CAL_MONTHS",
+                                    cycle_duration=1)
+
+        # Print the result DataFrames.
+        print(uaf_out.result)
+        print(uaf_out.metadata)
+    
+    """
+    

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

@@ -0,0 +1,174 @@
+def SelectionCriteria(data=None, data_filter_expr=None, var_count=None, 
+                      constant=False, use_likelihood=False, **generic_arguments):
+    """
+    DESCRIPTION:
+        The SelectionCriteria() function calculates metrics to help
+        determine the users for an forecast modeling project.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies a single multivariate series or a TDAnalyticResult object
+            created on the residual results from a previously run regression
+            operation. A single multivariate series has the following fields:
+                * First field is the original series value.
+                * Second field is the calculated series value from the model.
+                * Third field is the calculated residual, which is the original
+                  value minus the calculated value.
+            When TDAnalyticResult is used, make sure TDAnalyticResult is created without
+            passing the "layer" argument.
+            Types: TDSeries, TDAnalyticResult
+
+        data_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data".
+            Types: ColumnExpression
+
+        var_count:
+            Required Argument.
+            Specifies the total number of arguments present in the model.
+            Types: int
+
+        constant:
+            Optional Argument.
+            Specifies whether model has a constant. When set to False,
+            model has no constant, otherwise has constant.
+            Default Value: False
+            Types: bool
+
+        use_likelihood:
+            Optional Argument.
+            Specifies whether the selection criteria use residual sum squares
+            (RSS) or log-likelihood. When set to False, indicates RSS, otherwise
+            indicates log-likelihood.
+            Note:
+                * Applicable only when input is from the ArimaEstimate() function.
+            Default Value: False
+            Types: bool
+
+        **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 SelectionCriteria.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as SelectionCriteria_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", ["blood2ageandweight"])
+
+        # Create teradataml DataFrame object.
+        df = DataFrame.from_table("blood2ageandweight")
+
+        # Create teradataml TDSeries object.
+        series_arimaestimate = TDSeries(data=df,
+                                        id="PatientID",
+                                        row_index="SeqNo",
+                                        row_index_style="SEQUENCE",
+                                        payload_field="Age",
+                                        payload_content="REAL")
+
+        # Function outputs a result set that contains the estimated
+        # coefficients with accompanying per-coefficient statistical ratings.
+        arima_estimate = ArimaEstimate(data1=series_arimaestimate,
+                                       nonseasonal_model_order=[1,0,2],
+                                       constant=True,
+                                       algorithm='MLE',
+                                       fit_percentage=70,
+                                       coeff_stats=True,
+                                       fit_metrics=True,
+                                       residuals=True
+                                       )
+
+        # Example 1 : Calculate the metrics on the series created on the output
+        #             of ArimaEstimate() function.
+
+        # Create teradataml TDSeries object.
+        selectioncriteria_series = TDSeries(data=arima_estimate.fitresiduals,
+                                            id="PatientID",
+                                            row_index="ROW_I",
+                                            row_index_style= "SEQUENCE",
+                                            payload_field=["ACTUAL_VALUE",  "CALC_VALUE","RESIDUAL"],
+                                            payload_content="MULTIVAR_REAL")
+
+        uaf_out=SelectionCriteria(data=selectioncriteria_series,
+                                  var_count=4,
+                                  constant=True,
+                                  use_likelihood=False)
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+
+        # Example 2 : Calculate the metrics on the the output of ArimaEstimate()
+        #             function. Note that output of ArimaEstimate() is encapsulated
+        #             in TDAnalyticResult while passing as input.
+
+        # Create teradataml TDAnalyticResult object.
+        art_SelectionCriteria = TDAnalyticResult(data=arima_estimate.result)
+
+        uaf_out=SelectionCriteria(data=art_SelectionCriteria,var_count=4,
+                                  constant=True,
+                                  use_likelihood=True)
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+    
+    """
+    

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

@@ -0,0 +1,171 @@
+def SignifPeriodicities(data=None, data_filter_expr=None, 
+                        significance_level=None, periodicities=None, 
+                        **generic_arguments):
+    """
+    DESCRIPTION:
+        The SignifPeriodicities() function is a significance 
+        of periodicities statistics test to determine the 
+        optimum data model. It uses the residuals generated 
+        during the model validation/selection phase. 
+        Significance of periodicities statistics test is 
+        usually performed against residuals produced during 
+        the model validation phase, meaning against the 
+        in-sample forecasted data points.
+
+        The following procedure is an example of how to use 
+        SignifPeriodicities():
+            1. Use ArimaEstimate() to identify spectral candidates.
+            2. Use ArimaValidate() to validate spectral candidates.
+            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 
+               "periodicities" parameter.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies a single univariate series with calculated residuals
+            from original regression or TDAnalyticResult object on the 
+            residual output generated by the UAF functions.
+            Types: TDSeries, TDAnalyticResult
+
+        data_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data".
+            Types: ColumnExpression
+
+        significance_level:
+            Required Argument.
+            Specifies the significance level to be associated with
+            the statistical F-test. Value must be greater than 0 and
+            less than 1.
+            Types: float
+
+        periodicities:
+            Required Argument.
+            Specifies the significant periodicities to perform 
+            tests for each period.
+            Types: int, list of int, float, list of 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 SignifPeriodicities.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as SignifPeriodicities_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", "timeseriesdatasetsd4")
+
+        # Create teradataml DataFrame object.
+        data = DataFrame.from_table("timeseriesdatasetsd4")
+
+        # Create teradataml TDSeries object.
+        from teradataml import TDSeries
+        data_series_df = TDSeries(data = data, 
+                                  id="dataset_id", 
+                                  row_index="seqno", 
+                                  row_index_style="SEQUENCE",
+                                  payload_field = "Magnitude",
+                                  payload_content="REAL")
+
+        # Identify spectral candidates using ArimaEstimate().
+        from teradataml import ArimaEstimate
+        arima_estimate = ArimaEstimate(data1=data_series_df,
+                                       nonseasonal_model_order=[2, 0, 0],
+                                       constant=True,
+                                       algorithm="MLE",
+                                       fit_percentage=70,
+                                       fit_metrics=True,
+                                       coeff_stats=True,
+                                       residuals=True,
+                                       max_iterations=100)
+
+        # Create teradataml TDAnalyticResult object
+        # using the output of ArimaEstimate.
+        from teradataml import TDAnalyticResult
+        data_art_df = TDAnalyticResult(arima_estimate.result)
+
+        # Validate spectral candidates using ArimaValidate().
+        from teradataml import ArimaValidate
+        arima_validate = ArimaValidate(data=data_art_df,
+                                       fit_metrics=True,
+                                       residuals=True)
+
+        # Retrieve residuals from ArimaValidate() result.
+        data_series_df_real = TDSeries(data=arima_validate.fitresiduals,
+                                       id="dataset_id",
+                                       row_index="ROW_I",
+                                       row_index_style="SEQUENCE",
+                                       payload_field="RESIDUAL",
+                                       payload_content="REAL")
+
+        # Example 1: Perform statistical tests using SignifPeriodicities() 
+        #            function with TDSeries for multiple periodicities.
+        uaf_out = SignifPeriodicities(data=data_series_df_real, 
+                                      periodicities=[2.666666666, 5.333333333, 8.0], 
+                                      significance_level=0.05)
+
+        # Print the result DataFrame.
+        print(uaf_out.result)
+    
+    """

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

@@ -0,0 +1,164 @@
+def SignifResidmean(data=None, data_filter_expr=None, 
+                    significance_level=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The SignifResidmean() function is a significance of residual mean
+        statistics test to determine the optimum data model.
+        The function uses the residuals generated during model validation
+        that used the forecasted data points.
+
+        The following procedure is an example of how to use SignifResidmean() function:
+            1. Divide the sample data into two sets. One set is used to fit the data to the
+               model, and the other set is used to select between models.
+            2. Use ArimaEstimate() to determine the coefficients for the test statistics
+               to use with models.
+            3. Use ArimaValidate() to validate the goodness of the coefficients.
+            4. Use the residuals data from ArimaValidate() as an input for SignifResidmean().
+            5. Retrieve the null hypothesis results from the SignifResidmean() output.
+               A value of 1 means that the series has mean of zero. A value of 0 means
+               that the series has non-zero mean.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input series or a TDAnalyticResult object
+            created over the residuals data generated by the UAF function.
+            Types: TDSeries, TDAnalyticResult
+
+        data_filter_expr:
+            Optional Argument.
+            Specifies the filter expression for "data".
+            Types: ColumnExpression
+
+        significance_level:
+            Required Argument.
+            Specifies the significance level 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 SignifResidmean.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as SignifResidmean_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","timeseriesdatasetsd4")
+
+        # Create teradataml DataFrame object.
+        df = DataFrame.from_table("timeseriesdatasetsd4")
+
+        # Create teradataml TDSeries object for ArimaEstimate.
+        series_arimaestimate = TDSeries(data=df,
+                                        id="dataset_id",
+                                        row_index="seqno",
+                                        row_index_style="SEQUENCE",
+                                        payload_field="Magnitude",
+                                        payload_content="REAL")
+
+        # Function outputs a result set that contains the estimated
+        # coefficients with accompanying per-coefficient statistical ratings.
+        arima_estimate = ArimaEstimate(data1=series_arimaestimate,
+                                       nonseasonal_model_order=[1,0,0],
+                                       constant=True,
+                                       algorithm='MLE',
+                                       fit_percentage=70,
+                                       coeff_stats=True,
+                                       fit_metrics=True,
+                                       residuals=True)
+
+        # Create teradataml TDAnalyticResult object for ArimaValidate.
+        art_arimavalidate = TDAnalyticResult(data=arima_estimate.result)
+
+        # Validate the goodness of the coefficients.
+        arima_validate = ArimaValidate(data=art_arimavalidate,
+                                     fit_metrics=True,
+                                     residuals=True)
+
+        # Example 1: Determine the optimum data model using TDSeries created over
+        #            'fitresiduals' attribute of arima_validate as input.
+        # Create teradataml TDSeries object.
+        series_signifresidmean = TDSeries(data=arima_validate.fitresiduals,
+                                          id="dataset_id",
+                                          row_index="ROW_I",
+                                          row_index_style="SEQUENCE",
+                                          payload_field="RESIDUAL",
+                                          payload_content="REAL")
+
+        uaf_out1 = SignifResidmean(data=series_signifresidmean,
+                                   significance_level=0.05)
+
+        # Print the result DataFrame.
+        print(uaf_out1.result)
+
+        # Example 2: Determine the optimum data model using TDAnalyticResult created over
+        #            'result' attribute of arima_validate with layer as input.
+        # Create teradataml TDAnalyticResult object.
+        art_signifresidmean = TDAnalyticResult(data=arima_validate.result,
+                                               layer="ARTFITRESIDUALS")
+
+        uaf_out2 = SignifResidmean(data=art_signifresidmean,
+                                   significance_level=0.05)
+
+        # Print the result DataFrame.
+        print(uaf_out2.result)
+    """
+