batched_arima.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2021, NVIDIA CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <cuml/tsa/arima_common.h>
 
namespace raft {
class handle_t;
}
 
namespace ML {
 
enum LoglikeMethod { CSS, MLE };
 
void pack(raft::handle_t& handle,
          const ARIMAParams<double>& params,
          const ARIMAOrder& order,
          int batch_size,
          double* param_vec);
 
void unpack(raft::handle_t& handle,
            ARIMAParams<double>& params,
            const ARIMAOrder& order,
            int batch_size,
            const double* param_vec);
 
bool detect_missing(raft::handle_t& handle, const double* d_y, int n_elem);
 
void batched_diff(raft::handle_t& handle,
                  double* d_y_diff,
                  const double* d_y,
                  int batch_size,
                  int n_obs,
                  const ARIMAOrder& order);
 
void batched_loglike(raft::handle_t& handle,
                     const ARIMAMemory<double>& arima_mem,
                     const double* d_y,
                     const double* d_exog,
                     int batch_size,
                     int n_obs,
                     const ARIMAOrder& order,
                     const double* d_params,
                     double* loglike,
                     bool trans           = true,
                     bool host_loglike    = true,
                     LoglikeMethod method = MLE,
                     int truncate         = 0);
 
void batched_loglike(raft::handle_t& handle,
                     const ARIMAMemory<double>& arima_mem,
                     const double* d_y,
                     const double* d_exog,
                     int batch_size,
                     int n_obs,
                     const ARIMAOrder& order,
                     const ARIMAParams<double>& params,
                     double* loglike,
                     bool trans               = true,
                     bool host_loglike        = true,
                     LoglikeMethod method     = MLE,
                     int truncate             = 0,
                     int fc_steps             = 0,
                     double* d_fc             = nullptr,
                     const double* d_exog_fut = nullptr,
                     double level             = 0,
                     double* d_lower          = nullptr,
                     double* d_upper          = nullptr);
 
void batched_loglike_grad(raft::handle_t& handle,
                          const ARIMAMemory<double>& arima_mem,
                          const double* d_y,
                          const double* d_exog,
                          int batch_size,
                          int n_obs,
                          const ARIMAOrder& order,
                          const double* d_x,
                          double* d_grad,
                          double h,
                          bool trans           = true,
                          LoglikeMethod method = MLE,
                          int truncate         = 0);
 
void predict(raft::handle_t& handle,
             const ARIMAMemory<double>& arima_mem,
             const double* d_y,
             const double* d_exog,
             const double* d_exog_fut,
             int batch_size,
             int n_obs,
             int start,
             int end,
             const ARIMAOrder& order,
             const ARIMAParams<double>& params,
             double* d_y_p,
             bool pre_diff   = true,
             double level    = 0,
             double* d_lower = nullptr,
             double* d_upper = nullptr);
 
void information_criterion(raft::handle_t& handle,
                           const ARIMAMemory<double>& arima_mem,
                           const double* d_y,
                           const double* d_exog,
                           int batch_size,
                           int n_obs,
                           const ARIMAOrder& order,
                           const ARIMAParams<double>& params,
                           double* ic,
                           int ic_type);
 
void estimate_x0(raft::handle_t& handle,
                 ARIMAParams<double>& params,
                 const double* d_y,
                 const double* d_exog,
                 int batch_size,
                 int n_obs,
                 const ARIMAOrder& order,
                 bool missing);
 
}  // namespace ML