Add SVM Project files for OpenMP

Author: elixir-code

Diff for: Project/SVM-OpenMP/.gitignore

@@ -0,0 +1,35 @@
+# Build directory
+build/
+
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app

Diff for: Project/SVM-OpenMP/datasets/a1a

@@ -0,0 +1,7 @@
+1. Dataset Name: a1a
+
+Source: UCI/Adult
+
+# of classes  : 2
+# of data     : 1605/30956 (testing)
+# of features : 123/123 (testing)

Diff for: Project/SVM-OpenMP/datasets/a1a.t

@@ -0,0 +1,60 @@
+#ifndef CLASSIFIER_HPP
+#define CLASSIFIER_HPP
+
+#include <vector>
+using namespace std;
+
+#include "dataset.hpp"
+
+/* Classifier base class from which all classifiers derive */
+template <typename T>
+class Classifier
+{
+	// <define the parameters of the derived classifiers here>
+
+public:
+	// Fit the model with the dataset to learn parameters
+	virtual void fit(const Dataset<T>& dataset) = 0;
+
+	// Predict the class label for test data
+	virtual int predict(const vector<T>& data) = 0;
+
+	// Predict the class labels for test dataset
+	vector<int> predict(const Dataset<T>& dataset);
+};
+
+/* Support Vector Machine Classification Model */
+template <typename T>
+class SVC: public Classifier<T>
+{
+	// Parameters of the SVC classifier: C, tol, Kernel function
+	double C, tol, (*kernelFunction)(vector<T>, vector<T>), eps;
+	
+	// Dataset with which model was fitted (used in prediction)
+	Dataset<T> dataset;
+
+	// Parameters to be learnt from dataset: alphas[n_data], b
+	double *alphas, b;
+	
+	// error between prediction f(x) and actual value for examples in training data
+	double *errors;
+
+	// Helper functions to find alpha i (given alpha j) and update alpha i, alpha j pair
+	int findUpdateAlphaPair(int alpha2_index);
+	int updateAlphaPair(int alpha1_index, int alpha2_index);
+
+	// Syncronization variables to indicate that alpha i that can make positive progress was found
+	int valid_alpha1_found;
+
+public:
+
+	// Initialize the parameters for SVM Classifier
+	SVC(double C, double tol, double eps, double (*kernelFunction)(vector<T>, vector<T>));
+	
+	void fit(const Dataset<T>& dataset);
+	int predict(const vector<T>& data);
+
+	using Classifier<T>::predict;
+};
+
+#endif

Diff for: Project/SVM-OpenMP/datasets/datasets.metadata

@@ -0,0 +1,23 @@
+#ifndef DATASET_HPP
+#define DATASET_HPP
+
+#include <vector>
+using namespace std;
+
+/* An classification dataset with exclusively numerical features */
+template <typename T>
+class Dataset
+{
+public:	
+	vector<int> target;
+	vector<vector<T> > data;
+
+	int n_data;
+	int n_features;
+};
+
+/* Read a classification dataset from a libsvm file format */
+template <typename T>
+Dataset<T> readLibsvmDataset(const char *filename, int n_data, int n_features);
+
+#endif

Diff for: Project/SVM-OpenMP/include/classifier.hpp

@@ -0,0 +1,11 @@
+/* The file contains various default kernels for use in SVM classifier */
+#ifndef KERNELS_HPP
+#define KERNELS_HPP
+
+#include <vector>
+using namespace std;
+
+template <typename T>
+double dotProduct(vector<T>, vector<T>);
+
+#endif

Diff for: Project/SVM-OpenMP/include/dataset.hpp

@@ -0,0 +1,19 @@
+#ifndef VALIDATION_HPP
+#define VALIDATION_HPP
+
+#include <vector>
+using namespace std;
+
+// Computes the accuracy of the predictions by the classifier against true target values
+double computeAccuracy(const vector<int>& target, const vector<int>& predictions);
+
+// Computes the precision of the predictions by the classifier against true target values
+double computePrecision(const vector<int>& target, const vector<int>& predictions);
+
+// Computes the recall of the predictions by the classifier against true target values
+double computeRecall(const vector<int>& target, const vector<int>& predictions);
+
+// Computes the F1-score of the predictions by the classifier against true target values
+double computeF1Score(const vector<int>& target, const vector<int>& predictions);
+
+#endif

Diff for: Project/SVM-OpenMP/include/kernels.hpp

@@ -0,0 +1,70 @@
+CXX = g++
+LD = g++
+
+# path #
+SRC_PATH = src
+BUILD_PATH = build
+
+TEST_PATH = test
+BIN_PATH = $(BUILD_PATH)/bin
+
+# code lists #
+SOURCES = $(wildcard $(SRC_PATH)/*.cpp)
+OBJECTS = $(SOURCES:$(SRC_PATH)/%.cpp=$(BUILD_PATH)/%.o)
+DEPENDENCIES = $(OBJECTS:%.o=%.d)
+
+TEST_SOURCES = $(wildcard $(TEST_PATH)/*.cpp)
+TEST_OBJECTS = $(TEST_SOURCES:$(TEST_PATH)/%.cpp=$(BUILD_PATH)/%.o)
+TEST_DEPENDENCIES = $(TEST_OBJECTS:%.o=%.d)
+
+BINARIES = $(TEST_SOURCES:$(TEST_PATH)/%.cpp=$(BIN_PATH)/%)
+
+# flags #
+INCLUDES = -I include
+
+CXXFLAGS = -Wall -std=c++11 -fopenmp
+LDFLAGS = -fopenmp
+
+
+
+.PHONY: directories
+all: directories program
+
+-include $(DEPENDENCIES) $(TEST_DEPENDENCIES)
+
+# ----------------------------------------------------- #
+
+directories: $(BUILD_PATH) $(BIN_PATH)
+
+$(BUILD_PATH):
+	mkdir -p  $(BUILD_PATH)
+
+$(BIN_PATH):
+	mkdir -p $(BIN_PATH)	
+
+# ----------------------------------------------------- #
+
+.PHONY: program
+program: $(BINARIES)
+
+$(BIN_PATH)/%: $(OBJECTS) $(BUILD_PATH)/%.o
+	$(LD) $(LDFLAGS) $^ -o $@
+
+$(BUILD_PATH)/%.o: $(SRC_PATH)/%.cpp
+	$(CXX) $(CXXFLAGS) $(INCLUDES) -MMD -c $< -o $@
+
+$(BUILD_PATH)/%.o: $(TEST_PATH)/%.cpp
+	$(CXX) $(CXXFLAGS) $(INCLUDES) -MMD -c $< -o $@
+
+# ----------------------------------------------------- #
+
+.PHONY: clean
+clean:
+	rm -rf $(BIN_PATH)
+	rm -rf $(BUILD_PATH)
+
+# ----------------------------------------------------- #
+
+.SECONDARY: $(OBJECTS) $(TEST_OBJECTS)
+
+# ----------------------------------------------------- #

Diff for: Project/SVM-OpenMP/include/validation.hpp

@@ -0,0 +1,21 @@
+#include "classifier.hpp"
+
+template <typename T>
+vector<int> Classifier<T>::predict(const Dataset<T>& dataset)
+{
+	int prediction;
+	vector<int> predictions;
+
+	for(int i=0; i<(int)dataset.data.size(); ++i)
+	{
+		prediction = predict(dataset.data[i]);
+		predictions.push_back(prediction);
+	}
+
+	return predictions;
+}
+
+// Explicit instantiation of templated class and function
+template class Classifier<int>;
+template class Classifier<float>;
+template class Classifier<double>;

Diff for: Project/SVM-OpenMP/makefile

@@ -0,0 +1,70 @@
+#include "dataset.hpp"
+
+#include <fstream>
+#include <string>
+
+/* Read a classification dataset from a libsvm file format */
+template <typename T>
+Dataset<T> readLibsvmDataset(const char *filename, int n_data, int n_features)
+{
+	Dataset<T> dataset;
+
+	ifstream file(filename);
+	if(file.is_open())
+	{
+		string line, feature;
+		size_t current_pos, delimiter_pos, feature_delimiter_pos;
+
+		int i = 0, target, feature_index;
+		T feature_value;
+		vector<T> feature_vector(n_features);
+
+		while((i < n_data || n_data == -1) && getline(file, line)) 
+		{	
+			fill(feature_vector.begin(), feature_vector.end(), 0);
+
+			delimiter_pos = line.find(' ');
+			target = stoi(line.substr(0, delimiter_pos));
+
+			current_pos = delimiter_pos + 1;
+
+			// skip the spaces after target
+			while((current_pos < line.length()) && (line[current_pos] == ' '))
+				current_pos++;
+
+			while((delimiter_pos != string::npos) && (current_pos < line.length()))
+			{
+				delimiter_pos = line.find(' ', current_pos);
+				feature = line.substr(current_pos, delimiter_pos - current_pos);
+
+				feature_delimiter_pos = feature.find(':');
+
+				feature_index = stoi(feature.substr(0, feature_delimiter_pos));
+				feature_value = (T)stod(feature.substr(feature_delimiter_pos + 1));
+				feature_vector[feature_index-1] = feature_value;
+
+				current_pos = delimiter_pos + 1;
+			}
+
+			dataset.data.push_back(feature_vector);
+			dataset.target.push_back(target);
+
+			i++;
+		}
+
+		dataset.n_data = i;
+		dataset.n_features = n_features;
+	}
+
+	return dataset;
+}
+
+// Explicit declaration of templated class and function
+template class Dataset<int>;
+template Dataset<int> readLibsvmDataset<int>(const char *, int, int);
+
+template class Dataset<float>;
+template Dataset<float> readLibsvmDataset<float>(const char *, int, int);
+
+template class Dataset<double>;
+template Dataset<double> readLibsvmDataset<double>(const char *, int, int);

Diff for: Project/SVM-OpenMP/src/classifier.cpp

@@ -0,0 +1,23 @@
+#include "kernels.hpp"
+
+/* All Kernels assume that both vectors have same length */
+
+
+// Perform the for product of two feature vectors
+template <typename T>
+double dotProduct(vector<T> feature_vector1, vector<T> feature_vector2)
+{
+	int i;
+
+	double dot_product = 0;
+	
+	// #pragma omp parallel for private(i) reduction(+:dot_product)
+	for(i=0; i<(int)feature_vector1.size(); ++i)
+		dot_product += feature_vector1[i] * feature_vector2[i];
+	
+	return dot_product;
+}
+
+template double dotProduct(vector<int>, vector<int>);
+template double dotProduct(vector<float>, vector<float>);
+template double dotProduct(vector<double>, vector<double>);