Clustering

CMakeLists.txt

@@ -53,6 +53,22 @@ add_executable(RandomForestClassifier tests/tree/RandomForestClassifierTest.cpp)
 target_compile_definitions(RandomForestClassifier PRIVATE TEST_RANDOM_FOREST_CLASSIFIER)
 target_link_libraries(RandomForestClassifier cpp_ml_library)
 
+add_executable(KMeansClustering tests/clustering/KMeansClusteringTest.cpp)
+target_compile_definitions(KMeansClustering PRIVATE TEST_KMEANS_CLUSTERING)
+target_link_libraries(KMeansClustering cpp_ml_library)
+
+add_executable(KNNClassifier tests/clustering/KNNClassifierTest.cpp)
+target_compile_definitions(KNNClassifier PRIVATE TEST_KKN_CLASSIFIER)
+target_link_libraries(KNNClassifier cpp_ml_library)
+
+add_executable(KNNRegressor tests/clustering/KNNRegressorTest.cpp)
+target_compile_definitions(KNNRegressor PRIVATE TEST_KNN_REGRESSOR)
+target_link_libraries(KNNRegressor cpp_ml_library)
+
+add_executable(HierarchicalClustering tests/clustering/HierarchicalClusteringTest.cpp)
+target_compile_definitions(HierarchicalClustering PRIVATE TEST_HIERARCHICAL_CLUSTERING)
+target_link_libraries(HierarchicalClustering cpp_ml_library)
+
 # Register individual tests
 add_test(NAME LogisticRegressionTest COMMAND LogisticRegressionTest)
 add_test(NAME PolynomialRegressionTest COMMAND PolynomialRegressionTest)
@@ -61,6 +77,11 @@ add_test(NAME DecisionTreeRegressor COMMAND DecisionTreeRegressor)
 add_test(NAME RandomForestRegressor COMMAND RandomForestRegressor)
 add_test(NAME DecisionTreeClassifier COMMAND DecisionTreeClassifier)
 add_test(NAME RandomForestClassifier COMMAND RandomForestClassifier)
+add_test(NAME KMeansClustering COMMAND KMeansClustering)
+add_test(NAME KNNClassifier COMMAND KNNClassifier)
+add_test(NAME KNNRegressor COMMAND KNNRegressor)
+add_test(NAME HierarchicalClustering COMMAND HierarchicalClustering)
+
 
 # Add example executables if BUILD_EXAMPLES is ON
 if(BUILD_EXAMPLES)
@@ -87,6 +108,14 @@ if(BUILD_EXAMPLES)
             target_compile_definitions(${EXAMPLE_TARGET} PRIVATE TEST_DECISION_TREE_CLASSIFIER)
         elseif(EXAMPLE_NAME STREQUAL "RandomForestClassifierExample")
             target_compile_definitions(${EXAMPLE_TARGET} PRIVATE TEST_RANDOM_FOREST_CLASSIFIER)
+        elseif(EXAMPLE_NAME STREQUAL "KMeansExample")
+            target_compile_definitions(${EXAMPLE_TARGET} PRIVATE TEST_KMEANS_CLUSTERING)
+        elseif(EXAMPLE_NAME STREQUAL "KNNClassifierExample")
+            target_compile_definitions(${EXAMPLE_TARGET} PRIVATE TEST_KKN_CLASSIFIER)
+        elseif(EXAMPLE_NAME STREQUAL "KNNRegressorExample")
+            target_compile_definitions(${EXAMPLE_TARGET} PRIVATE TEST_KNN_REGRESSOR)
+        elseif(EXAMPLE_NAME STREQUAL "HierarchicalClusteringExample")
+            target_compile_definitions(${EXAMPLE_TARGET} PRIVATE TEST_HIERARCHICAL_CLUSTERING)
         endif()
     endforeach()
 endif()

README.md

@@ -61,17 +61,19 @@ The following machine learning algorithms are planned, inspired by concepts and
    - [x] Polynomial Regression
    - [x] Multi-Linear Regression
    - [x] Logistic Regression
-   - [ ] Decision Tree Regression
-   - [ ] Random Forest Regression
+   - [x] Decision Tree Regression
+   - [x] Random Forest Regression
+   - [ ] K-Nearest Neighbors
 
 
 2. **Classification**
-   - [ ] Decision Tree Classifier
-   - [ ] Random Forest Classifier
+   - [x] Decision Tree Classifier
+   - [x] Random Forest Classifier
    - [ ] K-Nearest Neighbors
 
 3. **Clustering**
    - [ ] K-Means Clustering
+   - [ ] Hierarchical clustering
 
 4. **Neural Networks**
    - [ ] Neural Network (NN)

examples/HierarchicalClusteringExample.cpp

@@ -0,0 +1,36 @@
+#include "../ml_library_include/ml/clustering/HierarchicalClustering.hpp"
+#include <iostream>
+
+int testHierarchicalClustering() {
+    // Sample data
+    std::vector<std::vector<double>> data = {
+        {1.0, 2.0},
+        {1.5, 1.8},
+        {5.0, 8.0},
+        {6.0, 9.0},
+        {1.0, 0.6},
+        {9.0, 11.0},
+        {8.0, 2.0},
+        {10.0, 2.0},
+        {9.0, 3.0}
+    };
+
+    // Create and fit the model
+    HierarchicalClustering hc(3, HierarchicalClustering::Linkage::AVERAGE);
+    hc.fit(data);
+
+    // Get cluster labels
+    std::vector<int> labels = hc.predict();
+
+    // Output cluster labels
+    for (size_t i = 0; i < labels.size(); ++i) {
+        std::cout << "Data point " << i << " is in cluster " << labels[i] << std::endl;
+    }
+
+    return 0;
+}
+
+int main(){
+    testHierarchicalClustering();
+    return 0;
+}

examples/KMeansExample.cpp

@@ -0,0 +1,45 @@
+#include "../ml_library_include/ml/clustering/KMeans.hpp"
+#include <iostream>
+
+int testKMeansClustering() {
+    // Sample data
+    std::vector<std::vector<double>> X = {
+        {1.0, 2.0},
+        {1.5, 1.8},
+        {5.0, 8.0},
+        {8.0, 8.0},
+        {1.0, 0.6},
+        {9.0, 11.0},
+        {8.0, 2.0},
+        {10.0, 2.0},
+        {9.0, 3.0},
+    };
+
+    // Create and fit the model
+    KMeans kmeans(3);
+    kmeans.fit(X);
+
+    // Predict cluster labels
+    std::vector<int> labels = kmeans.predict(X);
+
+    // Output results
+    for (size_t i = 0; i < labels.size(); ++i) {
+        std::cout << "Point: (" << X[i][0] << ", " << X[i][1] << ") - Cluster: " << labels[i] << std::endl;
+    }
+
+    // Get cluster centers
+    const auto& centers = kmeans.get_cluster_centers();
+    for (size_t k = 0; k < centers.size(); ++k) {
+        std::cout << "Cluster " << k << " center: (" << centers[k][0] << ", " << centers[k][1] << ")" << std::endl;
+    }
+
+    return 0;
+}
+
+// Only include main if TEST_DECISION_TREE_REGRESSION is defined
+//#ifdef TEST_KMEANS_CLUSTERING
+int main() {
+    testKMeansClustering();
+    return 0;
+}
+//#endif

examples/KNNClassifierExample.cpp

@@ -0,0 +1,41 @@
+#include "../ml_library_include/ml/clustering/KNNClassifier.hpp"
+#include <iostream>
+
+int testKNNClassifier() {
+    // Training data
+    std::vector<std::vector<double>> X_train = {
+        {1.0, 2.0},
+        {1.5, 1.8},
+        {5.0, 8.0},
+        {8.0, 8.0},
+        {1.0, 0.6},
+        {9.0, 11.0}
+    };
+    std::vector<int> y_train = {0, 0, 1, 1, 0, 1};
+
+    // Test data
+    std::vector<std::vector<double>> X_test = {
+        {1.0, 1.0},
+        {8.0, 9.0},
+        {0.0, 0.0}
+    };
+
+    // Create and train the classifier
+    KNNClassifier knn(3);
+    knn.fit(X_train, y_train);
+
+    // Make predictions
+    std::vector<int> predictions = knn.predict(X_test);
+
+    // Output predictions
+    for (size_t i = 0; i < predictions.size(); ++i) {
+        std::cout << "Sample " << i << " predicted class: " << predictions[i] << std::endl;
+    }
+
+    return 0;
+}
+
+int main(){
+    testKNNClassifier();
+    return 0;
+}

examples/KNNRegressorExample.cpp

@@ -0,0 +1,40 @@
+#include "../ml_library_include/ml/clustering/KNNRegressor.hpp"
+#include <iostream>
+
+int testKNNRegressor() {
+    // Training data
+    std::vector<std::vector<double>> X_train = {
+        {1.0},
+        {2.0},
+        {3.0},
+        {4.0},
+        {5.0}
+    };
+    std::vector<double> y_train = {2.0, 3.0, 4.0, 5.0, 6.0};
+
+    // Test data
+    std::vector<std::vector<double>> X_test = {
+        {1.5},
+        {2.5},
+        {3.5}
+    };
+
+    // Create and train the regressor
+    KNNRegressor knn(2);
+    knn.fit(X_train, y_train);
+
+    // Make predictions
+    std::vector<double> predictions = knn.predict(X_test);
+
+    // Output predictions
+    for (size_t i = 0; i < predictions.size(); ++i) {
+        std::cout << "Sample " << i << " predicted value: " << predictions[i] << std::endl;
+    }
+
+    return 0;
+}
+
+int main(){
+    testKNNRegressor();
+    return 0;
+}