rmontanana/Platform
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Create XBAODE classifier

Browse Source
This commit is contained in:
Ricardo Montañana Gómez
2025-02-23 19:44:13 +01:00
parent 1b26de1e38
commit 5daf7cbd69
7 changed files with 210 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/CMakeLists.txt
View File

@@ -26,6 +26,7 @@ add_executable(
reports/ReportExcel.cpp reports/ReportBase.cpp reports/ExcelFile.cpp
results/Result.cpp
experimental_clfs/XA1DE.cpp
experimental_clfs/XBAODE.cpp
)
target_link_libraries(b_best Boost::boost "${PyClassifiers}" "${BayesNet}" fimdlp ${Python3_LIBRARIES} "${TORCH_LIBRARIES}" ${LIBTORCH_PYTHON} Boost::python Boost::numpy "${XLSXWRITER_LIB}")
@@ -38,6 +39,7 @@ add_executable(b_grid commands/b_grid.cpp ${grid_sources}
reports/ReportConsole.cpp reports/ReportBase.cpp
results/Result.cpp
experimental_clfs/XA1DE.cpp
experimental_clfs/XBAODE.cpp
)
target_link_libraries(b_grid ${MPI_CXX_LIBRARIES} "${PyClassifiers}" "${BayesNet}" fimdlp ${Python3_LIBRARIES} "${TORCH_LIBRARIES}" ${LIBTORCH_PYTHON} Boost::python Boost::numpy)
@@ -48,6 +50,7 @@ add_executable(b_list commands/b_list.cpp
reports/ReportExcel.cpp reports/ExcelFile.cpp reports/ReportBase.cpp reports/DatasetsExcel.cpp reports/DatasetsConsole.cpp reports/ReportsPaged.cpp
results/Result.cpp results/ResultsDatasetExcel.cpp results/ResultsDataset.cpp results/ResultsDatasetConsole.cpp
experimental_clfs/XA1DE.cpp
experimental_clfs/XBAODE.cpp
)
target_link_libraries(b_list "${PyClassifiers}" "${BayesNet}" fimdlp ${Python3_LIBRARIES} "${TORCH_LIBRARIES}" ${LIBTORCH_PYTHON} Boost::python Boost::numpy "${XLSXWRITER_LIB}")
@@ -59,6 +62,7 @@ add_executable(b_main commands/b_main.cpp ${main_sources}
reports/ReportConsole.cpp reports/ReportBase.cpp
results/Result.cpp
experimental_clfs/XA1DE.cpp
experimental_clfs/XBAODE.cpp
)
target_link_libraries(b_main "${PyClassifiers}" "${BayesNet}" fimdlp ${Python3_LIBRARIES} "${TORCH_LIBRARIES}" ${LIBTORCH_PYTHON} Boost::python Boost::numpy)

6
src/experimental_clfs/XA1DE.h
View File

@@ -22,8 +22,6 @@ namespace platform {
public:
XA1DE();
virtual ~XA1DE() = default;
const std::string CLASSIFIER_NOT_FITTED = "Classifier has not been fitted";
XA1DE& fit(std::vector<std::vector<int>>& X, std::vector<int>& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const bayesnet::Smoothing_t smoothing) override;
XA1DE& fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const bayesnet::Smoothing_t smoothing) override;
XA1DE& fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const bayesnet::Smoothing_t smoothing) override;
@@ -49,10 +47,12 @@ namespace platform {
std::vector<std::string>& getValidHyperparameters() { return validHyperparameters; }
void setDebug(bool debug) { this->debug = debug; }
std::vector<std::string> graph(const std::string& title = "") const override { return {}; }
void set_active_parents(std::vector<int> active_parents) { aode_.set_active_parents(active_parents); }
protected:
void trainModel(const torch::Tensor& weights, const bayesnet::Smoothing_t smoothing) override {};
private:
const std::string CLASSIFIER_NOT_FITTED = "Classifier has not been fitted";
inline void normalize_weights(int num_instances)
{
double sum = std::accumulate(weights_.begin(), weights_.end(), 0.0);
@@ -74,7 +74,7 @@ namespace platform {
bayesnet::status_t status = bayesnet::NORMAL;
std::vector<std::string> notes;
bool use_threads = true;
std::string version = "0.9.7";
std::string version = "1.0.0";
bool fitted = false;
};
}

90
src/experimental_clfs/XBAODE.cpp Normal file
View File

@@ -0,0 +1,90 @@
// ***************************************************************
// SPDX-FileCopyrightText: Copyright 2025 Ricardo Montañana Gómez
// SPDX-FileType: SOURCE
// SPDX-License-Identifier: MIT
// ***************************************************************
#include "XBAODE.h"
namespace platform {
XBAODE::XBAODE() : semaphore_{ CountingSemaphore::getInstance() }
{
}
XBAODE& XBAODE::fit(std::vector<std::vector<int>>& X, std::vector<int>& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const bayesnet::Smoothing_t smoothing)
{
aode_.fit(X, y, features, className, states, smoothing);
fitted = true;
return *this;
}
std::vector<std::vector<double>> XBAODE::predict_proba(std::vector<std::vector<int>>& test_data)
{
return aode_.predict_proba_threads(test_data);
}
std::vector<int> XBAODE::predict(std::vector<std::vector<int>>& test_data)
{
if (!fitted) {
throw std::logic_error(CLASSIFIER_NOT_FITTED);
}
return aode_.predict(test_data);
}
float XBAODE::score(std::vector<std::vector<int>>& test_data, std::vector<int>& labels)
{
return aode_.score(test_data, labels);
}
//
// statistics
//
int XBAODE::getNumberOfNodes() const
{
return aode_.getNumberOfNodes();
}
int XBAODE::getNumberOfEdges() const
{
return aode_.getNumberOfEdges();
}
int XBAODE::getNumberOfStates() const
{
return aode_.getNumberOfStates();
}
int XBAODE::getClassNumStates() const
{
return aode_.getClassNumStates();
}
//
// Fit
//
// fit(std::vector<std::vector<int>>& X, std::vector<int>& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const bayesnet::Smoothing_t smoothing)
XBAODE& XBAODE::fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const bayesnet::Smoothing_t smoothing)
{
aode_.fit(X, y, features, className, states, smoothing);
return *this;
}
XBAODE& XBAODE::fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const bayesnet::Smoothing_t smoothing)
{
aode_.fit(dataset, features, className, states, smoothing);
return *this;
}
XBAODE& XBAODE::fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights, const bayesnet::Smoothing_t smoothing)
{
aode_.fit(dataset, features, className, states, weights, smoothing);
return *this;
}
//
// Predict
//
torch::Tensor XBAODE::predict(torch::Tensor& X)
{
return aode_.predict(X);
}
torch::Tensor XBAODE::predict_proba(torch::Tensor& X)
{
return aode_.predict_proba(X);
}
float XBAODE::score(torch::Tensor& X, torch::Tensor& y)
{
return aode_.score(X, y);
}
}

67
src/experimental_clfs/XBAODE.h Normal file
View File

@@ -0,0 +1,67 @@
// ***************************************************************
// SPDX-FileCopyrightText: Copyright 2025 Ricardo Montañana Gómez
// SPDX-FileType: SOURCE
// SPDX-License-Identifier: MIT
// ***************************************************************
#ifndef XBAODE_H
#define XBAODE_H
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <limits>
#include "common/Timer.hpp"
#include "CountingSemaphore.hpp"
#include "bayesnet/ensembles/Boost.h"
#include "XA1DE.h"
namespace platform {
class XBAODE : public bayesnet::Boost {
public:
XBAODE();
virtual ~XBAODE() = default;
const std::string CLASSIFIER_NOT_FITTED = "Classifier has not been fitted";
XBAODE& fit(std::vector<std::vector<int>>& X, std::vector<int>& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const bayesnet::Smoothing_t smoothing) override;
XBAODE& fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const bayesnet::Smoothing_t smoothing) override;
XBAODE& fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const bayesnet::Smoothing_t smoothing) override;
XBAODE& fit(torch::Tensor& dataset, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const torch::Tensor& weights, const bayesnet::Smoothing_t smoothing) override;
std::vector<int> predict(std::vector<std::vector<int>>& X) override;
torch::Tensor predict(torch::Tensor& X) override;
torch::Tensor predict_proba(torch::Tensor& X) override;
std::vector<std::vector<double>> predict_proba_threads(const std::vector<std::vector<int>>& test_data);
std::vector<std::vector<double>> predict_proba(std::vector<std::vector<int>>& X) override;
float score(std::vector<std::vector<int>>& X, std::vector<int>& y) override;
float score(torch::Tensor& X, torch::Tensor& y) override;
int getNumberOfNodes() const override;
int getNumberOfEdges() const override;
int getNumberOfStates() const override;
int getClassNumStates() const override;
bayesnet::status_t getStatus() const override { return status; }
std::string getVersion() override { return version; };
std::vector<std::string> show() const override { return {}; }
std::vector<std::string> topological_order() override { return {}; }
std::vector<std::string> getNotes() const override { return notes; }
std::string dump_cpt() const override { return ""; }
std::vector<std::string>& getValidHyperparameters() { return validHyperparameters; }
void setDebug(bool debug) { this->debug = debug; }
std::vector<std::string> graph(const std::string& title = "") const override { return {}; }
void set_active_parents(std::vector<int> active_parents) { aode_.set_active_parents(active_parents); }
protected:
void trainModel(const torch::Tensor& weights, const bayesnet::Smoothing_t smoothing) override {};
private:
XA1DE aode_;
std::vector<double> weights_;
CountingSemaphore& semaphore_;
bool debug = false;
bayesnet::status_t status = bayesnet::NORMAL;
std::vector<std::string> notes;
bool use_threads = true;
std::string version = "0.9.7";
bool fitted = false;
};
}
#endif // XBAODE_H

5
src/experimental_clfs/Xaode.hpp
View File

@@ -552,6 +552,10 @@ namespace platform {
{
return (nFeatures_ + 1) * nFeatures_;
}
void set_active_parents(std::vector<int> active_parents)
{
this->active_parents = active_parents;
}
private:
@@ -583,6 +587,7 @@ namespace platform {
MatrixState matrixState_;
double SMOOTHING = 1.0;
std::vector<int> active_parents;
};
}
#endif // XAODE_H

1
src/main/Models.h
View File

@@ -21,6 +21,7 @@
#include <pyclassifiers/XGBoost.h>
#include <pyclassifiers/RandomForest.h>
#include "../experimental_clfs/XA1DE.h"
#include "../experimental_clfs/XBAODE.h"
namespace platform {
class Models {
public:

44
src/main/modelRegister.h
View File

@@ -1,41 +1,43 @@
#ifndef MODELREGISTER_H
#define MODELREGISTER_H
static platform::Registrar registrarT("TAN",
namespace platform {
static Registrar registrarT("TAN",
[](void) -> bayesnet::BaseClassifier* { return new bayesnet::TAN();});
static platform::Registrar registrarTLD("TANLd",
static Registrar registrarTLD("TANLd",
[](void) -> bayesnet::BaseClassifier* { return new bayesnet::TANLd();});
static platform::Registrar registrarS("SPODE",
static Registrar registrarS("SPODE",
[](void) -> bayesnet::BaseClassifier* { return new bayesnet::SPODE(2);});
static platform::Registrar registrarSn("SPnDE",
static Registrar registrarSn("SPnDE",
[](void) -> bayesnet::BaseClassifier* { return new bayesnet::SPnDE({ 0, 1 });});
static platform::Registrar registrarSLD("SPODELd",
static Registrar registrarSLD("SPODELd",
[](void) -> bayesnet::BaseClassifier* { return new bayesnet::SPODELd(2);});
static platform::Registrar registrarK("KDB",
static Registrar registrarK("KDB",
[](void) -> bayesnet::BaseClassifier* { return new bayesnet::KDB(2);});
static platform::Registrar registrarKLD("KDBLd",
static Registrar registrarKLD("KDBLd",
[](void) -> bayesnet::BaseClassifier* { return new bayesnet::KDBLd(2);});
static platform::Registrar registrarA("AODE",
static Registrar registrarA("AODE",
[](void) -> bayesnet::BaseClassifier* { return new bayesnet::AODE();});
static platform::Registrar registrarA2("A2DE",
static Registrar registrarA2("A2DE",
[](void) -> bayesnet::BaseClassifier* { return new bayesnet::A2DE();});
static platform::Registrar registrarALD("AODELd",
static Registrar registrarALD("AODELd",
[](void) -> bayesnet::BaseClassifier* { return new bayesnet::AODELd();});
static platform::Registrar registrarBA("BoostAODE",
static Registrar registrarBA("BoostAODE",
[](void) -> bayesnet::BaseClassifier* { return new bayesnet::BoostAODE();});
static platform::Registrar registrarBA2("BoostA2DE",
static Registrar registrarBA2("BoostA2DE",
[](void) -> bayesnet::BaseClassifier* { return new bayesnet::BoostA2DE();});
static platform::Registrar registrarSt("STree",
static Registrar registrarSt("STree",
[](void) -> bayesnet::BaseClassifier* { return new pywrap::STree();});
static platform::Registrar registrarOdte("Odte",
static Registrar registrarOdte("Odte",
[](void) -> bayesnet::BaseClassifier* { return new pywrap::ODTE();});
static platform::Registrar registrarSvc("SVC",
static Registrar registrarSvc("SVC",
[](void) -> bayesnet::BaseClassifier* { return new pywrap::SVC();});
static platform::Registrar registrarRaF("RandomForest",
static Registrar registrarRaF("RandomForest",
[](void) -> bayesnet::BaseClassifier* { return new pywrap::RandomForest();});
static platform::Registrar registrarXGB("XGBoost",
static Registrar registrarXGB("XGBoost",
[](void) -> bayesnet::BaseClassifier* { return new pywrap::XGBoost();});
static platform::Registrar registrarXA1DE("XA1DE",
[](void) -> bayesnet::BaseClassifier* { return new platform::XA1DE();});
static Registrar registrarXA1DE("XA1DE",
[](void) -> bayesnet::BaseClassifier* { return new XA1DE();});
static Registrar registrarXBAODE("XBAODE",
[](void) -> bayesnet::BaseClassifier* { return new XBAODE();});
}
#endif