metrics.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/distance_type.hpp>
 
#include <cstdint>
 
namespace raft {
class handle_t;
}
 
namespace ML {
 
namespace Metrics {
 
float r2_score_py(const raft::handle_t& handle, float* y, float* y_hat, int n);
 
double r2_score_py(const raft::handle_t& handle, double* y, double* y_hat, int n);
 
double rand_index(const raft::handle_t& handle, double* y, double* y_hat, int n);
 
double silhouette_score(const raft::handle_t& handle,
                        double* y,
                        int nRows,
                        int nCols,
                        int* labels,
                        int nLabels,
                        double* silScores,
                        ML::distance::DistanceType metric);
 
namespace Batched {
float silhouette_score(const raft::handle_t& handle,
                       float* X,
                       int n_rows,
                       int n_cols,
                       int* y,
                       int n_labels,
                       float* scores,
                       int chunk,
                       ML::distance::DistanceType metric);
double silhouette_score(const raft::handle_t& handle,
                        double* X,
                        int n_rows,
                        int n_cols,
                        int* y,
                        int n_labels,
                        double* scores,
                        int chunk,
                        ML::distance::DistanceType metric);
 
}  // namespace Batched
double adjusted_rand_index(const raft::handle_t& handle,
                           const int64_t* y,
                           const int64_t* y_hat,
                           const int64_t n);
double adjusted_rand_index(const raft::handle_t& handle,
                           const int* y,
                           const int* y_hat,
                           const int n);
double kl_divergence(const raft::handle_t& handle, const double* y, const double* y_hat, int n);
 
float kl_divergence(const raft::handle_t& handle, const float* y, const float* y_hat, int n);
 
double entropy(const raft::handle_t& handle,
               const int* y,
               const int n,
               const int lower_class_range,
               const int upper_class_range);
 
double mutual_info_score(const raft::handle_t& handle,
                         const int* y,
                         const int* y_hat,
                         const int n,
                         const int lower_class_range,
                         const int upper_class_range);
 
double homogeneity_score(const raft::handle_t& handle,
                         const int* y,
                         const int* y_hat,
                         const int n,
                         const int lower_class_range,
                         const int upper_class_range);
 
double completeness_score(const raft::handle_t& handle,
                          const int* y,
                          const int* y_hat,
                          const int n,
                          const int lower_class_range,
                          const int upper_class_range);
 
double v_measure(const raft::handle_t& handle,
                 const int* y,
                 const int* y_hat,
                 const int n,
                 const int lower_class_range,
                 const int upper_class_range,
                 double beta);
 
float accuracy_score_py(const raft::handle_t& handle,
                        const int* predictions,
                        const int* ref_predictions,
                        int n);
 
void pairwise_distance(const raft::handle_t& handle,
                       const double* x,
                       const double* y,
                       double* dist,
                       int m,
                       int n,
                       int k,
                       ML::distance::DistanceType metric,
                       bool isRowMajor   = true,
                       double metric_arg = 2.0);
 
void pairwise_distance(const raft::handle_t& handle,
                       const float* x,
                       const float* y,
                       float* dist,
                       int m,
                       int n,
                       int k,
                       ML::distance::DistanceType metric,
                       bool isRowMajor  = true,
                       float metric_arg = 2.0f);
 
void pairwiseDistance_sparse(const raft::handle_t& handle,
                             double* x,
                             double* y,
                             double* dist,
                             int x_nrows,
                             int y_nrows,
                             int n_cols,
                             int x_nnz,
                             int y_nnz,
                             int* x_indptr,
                             int* y_indptr,
                             int* x_indices,
                             int* y_indices,
                             ML::distance::DistanceType metric,
                             float metric_arg);
void pairwiseDistance_sparse(const raft::handle_t& handle,
                             float* x,
                             float* y,
                             float* dist,
                             int x_nrows,
                             int y_nrows,
                             int n_cols,
                             int x_nnz,
                             int y_nnz,
                             int* x_indptr,
                             int* y_indptr,
                             int* x_indices,
                             int* y_indices,
                             ML::distance::DistanceType metric,
                             float metric_arg);
 
template <typename math_t, ML::distance::DistanceType distance_type>
double trustworthiness_score(const raft::handle_t& h,
                             const math_t* X,
                             math_t* X_embedded,
                             int n,
                             int m,
                             int d,
                             int n_neighbors,
                             int batchSize = 512);
 
}  // namespace Metrics
}  // namespace ML