glm.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2022, 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/linear_model/qn.h>
 
#include <raft/core/handle.hpp>
 
namespace ML {
namespace GLM {
 
void olsFit(const raft::handle_t& handle,
            float* input,
            size_t n_rows,
            size_t n_cols,
            float* labels,
            float* coef,
            float* intercept,
            bool fit_intercept,
            bool normalize,
            int algo             = 0,
            float* sample_weight = nullptr);
void olsFit(const raft::handle_t& handle,
            double* input,
            size_t n_rows,
            size_t n_cols,
            double* labels,
            double* coef,
            double* intercept,
            bool fit_intercept,
            bool normalize,
            int algo              = 0,
            double* sample_weight = nullptr);
void ridgeFit(const raft::handle_t& handle,
              float* input,
              size_t n_rows,
              size_t n_cols,
              float* labels,
              float* alpha,
              int n_alpha,
              float* coef,
              float* intercept,
              bool fit_intercept,
              bool normalize,
              int algo             = 0,
              float* sample_weight = nullptr);
void ridgeFit(const raft::handle_t& handle,
              double* input,
              size_t n_rows,
              size_t n_cols,
              double* labels,
              double* alpha,
              int n_alpha,
              double* coef,
              double* intercept,
              bool fit_intercept,
              bool normalize,
              int algo              = 0,
              double* sample_weight = nullptr);
void gemmPredict(const raft::handle_t& handle,
                 const float* input,
                 size_t n_rows,
                 size_t n_cols,
                 const float* coef,
                 float intercept,
                 float* preds);
void gemmPredict(const raft::handle_t& handle,
                 const double* input,
                 size_t n_rows,
                 size_t n_cols,
                 const double* coef,
                 double intercept,
                 double* preds);
template <typename T, typename I = int>
void qnFit(const raft::handle_t& cuml_handle,
           const qn_params& params,
           T* X,
           bool X_col_major,
           T* y,
           I N,
           I D,
           I C,
           T* w0,
           T* f,
           int* num_iters,
           T* sample_weight = nullptr,
           T svr_eps        = 0);
 
template <typename T, typename I = int>
void qnFitSparse(const raft::handle_t& cuml_handle,
                 const qn_params& params,
                 T* X_values,
                 I* X_cols,
                 I* X_row_ids,
                 I X_nnz,
                 T* y,
                 I N,
                 I D,
                 I C,
                 T* w0,
                 T* f,
                 int* num_iters,
                 T* sample_weight = nullptr,
                 T svr_eps        = 0);
 
template <typename T, typename I = int>
void qnDecisionFunction(const raft::handle_t& cuml_handle,
                        const qn_params& params,
                        T* X,
                        bool X_col_major,
                        I N,
                        I D,
                        I C,
                        T* coefs,
                        T* scores);
 
template <typename T, typename I = int>
void qnDecisionFunctionSparse(const raft::handle_t& cuml_handle,
                              const qn_params& params,
                              T* X_values,
                              I* X_cols,
                              I* X_row_ids,
                              I X_nnz,
                              I N,
                              I D,
                              I C,
                              T* coefs,
                              T* scores);
 
template <typename T, typename I = int>
void qnPredict(const raft::handle_t& cuml_handle,
               const qn_params& params,
               T* X,
               bool X_col_major,
               I N,
               I D,
               I C,
               T* coefs,
               T* preds);
 
template <typename T, typename I = int>
void qnPredictSparse(const raft::handle_t& cuml_handle,
                     const qn_params& params,
                     T* X_values,
                     I* X_cols,
                     I* X_row_ids,
                     I X_nnz,
                     I N,
                     I D,
                     I C,
                     T* coefs,
                     T* preds);
 
}  // namespace GLM
}  // namespace ML