Support Vector Classifier (SVC) for binary classification using Stochastic Gradient Descent. More...

#include <svc.hpp>

Public Member Functions
	SVC (double C_=1.0, double l_rate=0.01, int max_iters=1000, double tol=1e-4)
	Constructor for SVC class. More...

void	fit (const std::vector< std::vector< double >> &X_train, const std::vector< int > &y_train)
	Fit the SVC model to the training data. More...

std::vector< int >	predict (const std::vector< std::vector< double >> &X_test)
	Predict labels for given test data. More...

std::vector< double >	predict_proba (const std::vector< std::vector< double >> &X_test)
	Predict class probabilities for given test data. More...

double	score (const std::vector< std::vector< double >> &X_test, const std::vector< int > &y_test)
	Calculate the accuracy of the model on given test data. More...

void	set_kernel (const std::string &k_type)
	Set the kernel type for the SVC. More...

void	set_kernel_parameters (double k_param)
	Set the kernel parameters for the SVC. More...

void	set_random_state (int seed)
	Set the random seed for reproducibility. More...

void	set_verbose (bool vbose)
	Enable or disable verbose output during training. More...

void	set_penalty (const std::string &p_type)
	Set the penalty type for regularization. More...

double	cross_val_score (const std::vector< std::vector< double >> &X, const std::vector< int > &y, int cv=5)
	Perform k-fold cross-validation on the model. More...

std::vector< double >	grid_search (const std::vector< std::vector< double >> &X, const std::vector< int > &y, const std::vector< double > &C_values, const std::vector< double > &kernel_params, int cv=5)
	Perform grid search for hyperparameter tuning. More...

double	hinge_loss (double prediction, int label)
	Compute the hinge loss for a given prediction and true label. More...

double	compute_loss (const std::vector< std::vector< double >> &X, const std::vector< int > &y)
	Compute the total loss (including regularization) for the model. More...

void	update_weights (const std::vector< std::vector< double >> &X, const std::vector< int > &y)
	Update weights and bias using stochastic gradient descent. More...

double	kernel (const std::vector< double > &x1, const std::vector< double > &x2)
	Compute the kernel function between two vectors. More...

double	dot_product (const std::vector< double > &x1, const std::vector< double > &x2)
	Compute the dot product between two vectors. More...

double	sigmoid (double z)
	Sigmoid activation function. More...

std::vector< int >	k_fold_indices (int num_instances, int k)
	Generate k-fold indices for cross-validation. More...

double	accuracy (const std::vector< int > &predictions, const std::vector< int > &labels)
	Compute the accuracy of predictions. More...

Public Attributes
double	C

double	learning_rate

int	max_iterations

double	tolerance

std::string	kernel_type

double	kernel_param

int	random_state

bool	verbose

std::string	penalty_type

std::vector< double >	weights

double	bias

Detailed Description

Support Vector Classifier (SVC) for binary classification using Stochastic Gradient Descent.

Definition at line 50 of file svc.hpp.

Constructor & Destructor Documentation

◆ SVC()

gpmp::ml::SVC::SVC	(	double	C_ = `1.0`,
		double	l_rate = `0.01`,
		int	max_iters = `1000`,
		double	tol = `1e-4`
	)

Constructor for SVC class.

Parameters

C_	Regularization parameter (default: 1.0)
l_rate	Learning rate for stochastic gradient descent (default: 0.01)
max_iters	Maximum number of iterations for training (default: 1000)
tol	Tolerance for convergence (default: 1e-4)

Definition at line 38 of file svc.cpp.

39 : C(C_), learning_rate(l_rate), max_iterations(max_iters), tolerance(tol) {

40 }

gpmp::ml::SVC::learning_rate

double learning_rate

Definition: svc.hpp:157

gpmp::ml::SVC::tolerance

double tolerance

Definition: svc.hpp:161

gpmp::ml::SVC::max_iterations

int max_iterations

Definition: svc.hpp:159

gpmp::ml::SVC::C

double C

Definition: svc.hpp:155

Member Function Documentation

◆ accuracy()

double gpmp::ml::SVC::accuracy	(	const std::vector< int > &	predictions,
		const std::vector< int > &	labels
	)

Compute the accuracy of predictions.

Parameters

predictions	Predicted labels
labels	True labels

Returns: Accuracy

Definition at line 249 of file svc.cpp.

                                                              {
     int correct = 0;
     for (size_t i = 0; i < predictions.size(); ++i) {
         if (predictions[i] == labels[i]) {
             correct++;
         }
     }
     return static_cast<double>(correct) / predictions.size();
 }

◆ compute_loss()

double gpmp::ml::SVC::compute_loss	(	const std::vector< std::vector< double >> &	X,
		const std::vector< int > &	y
	)

Compute the total loss (including regularization) for the model.

Parameters

X	Input features
y	True labels

Returns: Total loss

Definition at line 79 of file svc.cpp.

                                                             {
     double loss = 0.0;
     for (size_t i = 0; i < X.size(); ++i) {
         double prediction = 0.0;
         for (size_t j = 0; j < X[i].size(); ++j) {
             prediction += X[i][j] * weights[j];
         }
         prediction += bias;
         loss += hinge_loss(prediction, y[i]);
     }
     // Add L2 regularization
     for (double weight : weights) {
         loss += 0.5 * C * weight * weight;
     }
     return loss / X.size();
 }

References python.linalg::C.

◆ cross_val_score()

double gpmp::ml::SVC::cross_val_score	(	const std::vector< std::vector< double >> &	X,
		const std::vector< int > &	y,
		int	cv = `5`
	)

Perform k-fold cross-validation on the model.

Parameters

X	Input features for cross-validation
y	True labels for cross-validation
cv	Number of folds (default: 5)

Returns: Average accuracy over the folds

Definition at line 158 of file svc.cpp.

                                               {
     std::vector<int> fold_sizes = k_fold_indices(X.size(), cv);
     double avg_score = 0.0;
     for (int i = 0; i < cv; ++i) {
         std::vector<std::vector<double>> X_train, X_valid;
         std::vector<int> y_train, y_valid;
         int start = 0;
         for (int j = 0; j < cv; ++j) {
             if (j != i) {
                 int end = start + fold_sizes[j];
                 for (int k = start; k < end; ++k) {
                     X_train.push_back(X[k]);
                     y_train.push_back(y[k]);
                 }
             } else {
                 int end = start + fold_sizes[j];
                 for (int k = start; k < end; ++k) {
                     X_valid.push_back(X[k]);
                     y_valid.push_back(y[k]);
                 }
             }
             start += fold_sizes[j];
         }
         fit(X_train, y_train);
         double score_val = score(X_valid, y_valid);
         if (verbose) {
             std::cout << "Cross-validation fold " << i + 1
                       << " accuracy: " << score_val << std::endl;
         }
         avg_score += score_val;
     }
     return avg_score / cv;
 }

◆ dot_product()

double gpmp::ml::SVC::dot_product	(	const std::vector< double > &	x1,
		const std::vector< double > &	x2
	)

Compute the dot product between two vectors.

Parameters

x1	First vector
x2	Second vector

Returns: Dot product

Definition at line 227 of file svc.cpp.

                                                                {
     double result = 0.0;
     for (size_t i = 0; i < x1.size(); ++i) {
         result += x1[i] * x2[i];
     }
     return result;
 }

◆ fit()

void gpmp::ml::SVC::fit	(	const std::vector< std::vector< double >> &	X_train,
		const std::vector< int > &	y_train
	)

Fit the SVC model to the training data.

Parameters

X_train	Input features for training
y_train	Labels for training

Definition at line 42 of file svc.cpp.

                                                        {
     // Initialize weights and bias
     weights.resize(X_train[0].size(), 0.0);
     bias = 0.0;
  
     // Stochastic Gradient Descent
     for (int iter = 0; iter < max_iterations; ++iter) {
         update_weights(X_train, y_train);
  
         // Check convergence
         double loss = compute_loss(X_train, y_train);
         if (loss < tolerance) {
             break;
         }
     }
 }

◆ grid_search()

std::vector< double > gpmp::ml::SVC::grid_search	(	const std::vector< std::vector< double >> &	X,
		const std::vector< int > &	y,
		const std::vector< double > &	C_values,
		const std::vector< double > &	kernel_params,
		int	cv = `5`
	)

Perform grid search for hyperparameter tuning.

Parameters

X	Input features for grid search
y	True labels for grid search
C_values	Candidate values for the regularization parameter
kernel_params	Candidate values for the kernel parameter
cv	Number of folds for cross-validation (default: 5)

Returns: Best hyperparameters found Regularization parameter

Definition at line 195 of file svc.cpp.

                                    {
     std::vector<double> best_params;
     double best_score = 0.0;
     for (double val : C_values) {
         for (double param : kernel_params) {
             set_kernel_parameters(param);
             set_penalty("l2");  // Default penalty type
             set_verbose(false); // Suppress verbose output
             double score = cross_val_score(X, y, cv);
             if (score > best_score) {
                 best_score = score;
                 best_params = {val, param};
             }
         }
     }
     return best_params;
 }

◆ hinge_loss()

double gpmp::ml::SVC::hinge_loss	(	double	prediction,
		int	label
	)

Compute the hinge loss for a given prediction and true label.

Parameters

prediction	Predicted value
label	True label

Returns: Hinge loss

Definition at line 75 of file svc.cpp.

                                                          {
     return fmax(0, 1 - label * prediction);
 }

◆ k_fold_indices()

std::vector< int > gpmp::ml::SVC::k_fold_indices	(	int	num_instances,
		int	k
	)

Generate k-fold indices for cross-validation.

Parameters

num_instances	Total number of instances
k	Number of folds

Returns: Vector of fold sizes

Definition at line 240 of file svc.cpp.

                                                                  {
     std::vector<int> fold_sizes(k, num_instances / k);
     int remainder = num_instances % k;
     for (int i = 0; i < remainder; ++i) {
         fold_sizes[i]++;
     }
     return fold_sizes;
 }

◆ kernel()

double gpmp::ml::SVC::kernel	(	const std::vector< double > &	x1,
		const std::vector< double > &	x2
	)

Compute the kernel function between two vectors.

Parameters

x1	First vector
x2	Second vector

Returns: Kernel value

Definition at line 217 of file svc.cpp.

                                                           {
     if (kernel_type == "linear") {
         return dot_product(x1, x2);
     } else {
         // Default to linear kernel if unknown kernel type
         return dot_product(x1, x2);
     }
 }

References gpmp::linalg::dot_product().

◆ predict()

std::vector< int > gpmp::ml::SVC::predict ( const std::vector< std::vector< double >> & X_test )

Predict labels for given test data.

Parameters

X_test Input features for prediction

Returns: Predicted labels

Definition at line 61 of file svc.cpp.

                                                              {
     std::vector<int> predictions;
     for (const auto &instance : X_test) {
         double score = 0.0;
         for (size_t i = 0; i < instance.size(); ++i) {
             score += instance[i] * weights[i];
         }
         score += bias;
         int prediction = (score >= 0) ? 1 : -1;
         predictions.push_back(prediction);
     }
     return predictions;
 }

◆ predict_proba()

std::vector< double > gpmp::ml::SVC::predict_proba ( const std::vector< std::vector< double >> & X_test )

Predict class probabilities for given test data.

Parameters

X_test Input features for prediction

Returns: Predicted class probabilities

Definition at line 118 of file svc.cpp.

                                                                    {
     std::vector<double> probabilities;
     for (const auto &instance : X_test) {
         double score = 0.0;
         for (size_t i = 0; i < instance.size(); ++i) {
             score += instance[i] * weights[i];
         }
         score += bias;
         double prob = sigmoid(score);
         probabilities.push_back(prob);
     }
     return probabilities;
 }

◆ score()

double gpmp::ml::SVC::score	(	const std::vector< std::vector< double >> &	X_test,
		const std::vector< int > &	y_test
	)

Calculate the accuracy of the model on given test data.

Parameters

X_test	Input features for evaluation
y_test	True labels for evaluation

Returns: Accuracy of the model

Definition at line 132 of file svc.cpp.

                                                           {
     std::vector<int> predictions = predict(X_test);
     return accuracy(predictions, y_test);
 }

◆ set_kernel()

void gpmp::ml::SVC::set_kernel ( const std::string & k_type )

Set the kernel type for the SVC.

Parameters

k_type Kernel type (eg, "linear")

Definition at line 138 of file svc.cpp.

                                                   {
     this->kernel_type = k_type;
 }

◆ set_kernel_parameters()

void gpmp::ml::SVC::set_kernel_parameters ( double k_param )

Set the kernel parameters for the SVC.

Parameters

k_param Kernel parameter value

Definition at line 142 of file svc.cpp.

                                                     {
     this->kernel_param = k_param;
 }

◆ set_penalty()

void gpmp::ml::SVC::set_penalty ( const std::string & p_type )

Set the penalty type for regularization.

Parameters

p_type Penalty type (eg, "l2")

Definition at line 154 of file svc.cpp.

                                                    {
     this->penalty_type = p_type;
 }

◆ set_random_state()

void gpmp::ml::SVC::set_random_state ( int seed )

Set the random seed for reproducibility.

Parameters

seed	Random seed

Definition at line 146 of file svc.cpp.

                                          {
     this->random_state = seed;
 }

◆ set_verbose()

void gpmp::ml::SVC::set_verbose ( bool vbose )

Enable or disable verbose output during training.

Parameters

vbose Verbose flag

Definition at line 150 of file svc.cpp.

                                       {
     this->verbose = vbose;
 }

◆ sigmoid()

double gpmp::ml::SVC::sigmoid ( double z )

Sigmoid activation function.

Parameters

z	Input value

Returns: Sigmoid value

Definition at line 236 of file svc.cpp.

                                   {
     return 1.0 / (1.0 + exp(-z));
 }

◆ update_weights()

void gpmp::ml::SVC::update_weights	(	const std::vector< std::vector< double >> &	X,
		const std::vector< int > &	y
	)

Update weights and bias using stochastic gradient descent.

Parameters

X	Input features
y	True labels

Definition at line 97 of file svc.cpp.

                                                             {
     for (size_t i = 0; i < X.size(); ++i) {
         double prediction = 0.0;
         for (size_t j = 0; j < X[i].size(); ++j) {
             prediction += X[i][j] * weights[j];
         }
         prediction += bias;
         double loss_grad = -y[i] * (1 - prediction);
         if (loss_grad > 0) {
             // Update weights
             for (size_t j = 0; j < X[i].size(); ++j) {
                 weights[j] -= learning_rate * (C * weights[j] - y[i] * X[i][j]);
             }
             // Update bias
             bias -= learning_rate * y[i];
         }
     }
 }

References python.linalg::C.

Member Data Documentation

◆ bias

double gpmp::ml::SVC::bias

Definition at line 175 of file svc.hpp.

◆ C

double gpmp::ml::SVC::C

Learning rate for stochastic gradient descent

Definition at line 155 of file svc.hpp.

◆ kernel_param

double gpmp::ml::SVC::kernel_param

Random seed for reproducibility

Definition at line 165 of file svc.hpp.

◆ kernel_type

std::string gpmp::ml::SVC::kernel_type

Kernel parameter for the selected kernel

Definition at line 163 of file svc.hpp.

◆ learning_rate

double gpmp::ml::SVC::learning_rate

Maximum number of iterations for training

Definition at line 157 of file svc.hpp.

◆ max_iterations

int gpmp::ml::SVC::max_iterations

Tolerance for convergence

Definition at line 159 of file svc.hpp.

◆ penalty_type

std::string gpmp::ml::SVC::penalty_type

Model weights

Definition at line 171 of file svc.hpp.

◆ random_state

int gpmp::ml::SVC::random_state

Verbose flag for training output

Definition at line 167 of file svc.hpp.

◆ tolerance

double gpmp::ml::SVC::tolerance

Kernel type for SVC

Definition at line 161 of file svc.hpp.

◆ verbose

bool gpmp::ml::SVC::verbose

Penalty type for regularization

Definition at line 169 of file svc.hpp.

◆ weights

std::vector<double> gpmp::ml::SVC::weights

Model bias

Definition at line 173 of file svc.hpp.

The documentation for this class was generated from the following files:

include/openGPMP/ml/svc.hpp
modules/ml/svc.cpp

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SVC()

Member Function Documentation

◆ accuracy()

◆ compute_loss()

◆ cross_val_score()

◆ dot_product()

◆ fit()

◆ grid_search()

◆ hinge_loss()

◆ k_fold_indices()

◆ kernel()

◆ predict()

◆ predict_proba()

◆ score()

◆ set_kernel()

◆ set_kernel_parameters()

◆ set_penalty()

◆ set_random_state()

◆ set_verbose()

◆ sigmoid()

◆ update_weights()

Member Data Documentation

◆ bias

◆ C

◆ kernel_param

◆ kernel_type

◆ learning_rate

◆ max_iterations

◆ penalty_type

◆ random_state

◆ tolerance

◆ verbose

◆ weights