linear.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2021-2025, 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/common/logger.hpp>
 
#include <raft/core/handle.hpp>
 
namespace ML {
namespace SVM {
 
struct LinearSVMParams {
  enum Penalty {
    L1,
    L2
  };
  enum Loss {
    HINGE,
    SQUARED_HINGE,
    EPSILON_INSENSITIVE,
    SQUARED_EPSILON_INSENSITIVE
  };
 
  Penalty penalty = L2;
  Loss loss = HINGE;
  bool fit_intercept = true;
  bool penalized_intercept = false;
  bool probability = false;
  int max_iter = 1000;
  int linesearch_max_iter = 100;
  int lbfgs_memory = 5;
  rapids_logger::level_enum verbose = rapids_logger::level_enum::off;
  double C = 1.0;
  double grad_tol = 0.0001;
  double change_tol = 0.00001;
  double epsilon = 0.0;
};
 
template <typename T>
struct LinearSVMModel {
  T* w;
  T* classes = nullptr;
  T* probScale = nullptr;
  std::size_t nClasses = 0;
  std::size_t coefRows;
 
  inline std::size_t coefCols() const { return nClasses <= 2 ? 1 : nClasses; }
 
  static LinearSVMModel<T> fit(const raft::handle_t& handle,
                               const LinearSVMParams& params,
                               const T* X,
                               const std::size_t nRows,
                               const std::size_t nCols,
                               const T* y,
                               const T* sampleWeight);
 
  static LinearSVMModel<T> allocate(const raft::handle_t& handle,
                                    const LinearSVMParams& params,
                                    const std::size_t nCols,
                                    const std::size_t nClasses = 0);
 
  static void free(const raft::handle_t& handle, LinearSVMModel<T>& model);
 
  static void predict(const raft::handle_t& handle,
                      const LinearSVMParams& params,
                      const LinearSVMModel<T>& model,
                      const T* X,
                      const std::size_t nRows,
                      const std::size_t nCols,
                      T* out);
 
  static void decisionFunction(const raft::handle_t& handle,
                               const LinearSVMParams& params,
                               const LinearSVMModel<T>& model,
                               const T* X,
                               const std::size_t nRows,
                               const std::size_t nCols,
                               T* out);
 
  static void predictProba(const raft::handle_t& handle,
                           const LinearSVMParams& params,
                           const LinearSVMModel<T>& model,
                           const T* X,
                           const std::size_t nRows,
                           const std::size_t nCols,
                           const bool log,
                           T* out);
};
 
}  // namespace SVM
}  // namespace ML