rmontanana/BayesNet
1
0
Fork 0
Code Issues 2 Pull Requests 1 Actions Packages Projects Releases 6 Wiki Activity

Add Makefile & tests

Browse Source
This commit is contained in:
Ricardo Montañana Gómez
2023-07-17 22:51:15 +02:00
parent f530e69dae
commit ca72a34131
10 changed files with 303 additions and 365 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
sample/CMakeLists.txt
View File

@@ -1,6 +1,4 @@
include_directories(${BayesNet_SOURCE_DIR}/src)
link_directories(${MyProject_SOURCE_DIR}/src)
add_executable(main main.cc ArffFiles.cc CPPFImdlp.cpp Metrics.cpp)
add_executable(test test.cc)
target_link_libraries(main BayesNet "${TORCH_LIBRARIES}")
target_link_libraries(test "${TORCH_LIBRARIES}")
target_link_libraries(main BayesNet "${TORCH_LIBRARIES}")

221
sample/main.cc
View File

@@ -30,23 +30,23 @@ void usage(const char* path)
<< " -f, --file[=FILENAME]\t {diabetes, glass, iris, kdd_JapaneseVowels, letter, liver-disorders, mfeat-factors}."
<< endl;
cout << " -p, --path[=FILENAME]\t folder where the data files are located, default " << PATH << endl;
cout << " -n, --net=[FILENAME]\t default=file parameter value" << endl;
cout << " -m, --model={AODE, KDB, SPODE, TAN}\t " << endl;
}
tuple<string, string, string> parse_arguments(int argc, char** argv)
{
string file_name;
string network_name;
string model_name;
string path = PATH;
const vector<struct option> long_options = {
{"help", no_argument, nullptr, 'h'},
{"file", required_argument, nullptr, 'f'},
{"path", required_argument, nullptr, 'p'},
{"net", required_argument, nullptr, 'n'},
{"model", required_argument, nullptr, 'm'},
{nullptr, no_argument, nullptr, 0}
};
while (true) {
const auto c = getopt_long(argc, argv, "hf:p:n:", long_options.data(), nullptr);
const auto c = getopt_long(argc, argv, "hf:p:m:", long_options.data(), nullptr);
if (c == -1)
break;
switch (c) {
@@ -56,8 +56,8 @@ tuple<string, string, string> parse_arguments(int argc, char** argv)
case 'f':
file_name = string(optarg);
break;
case 'n':
network_name = string(optarg);
case 'm':
model_name = string(optarg);
break;
case 'p':
path = optarg;
@@ -75,12 +75,22 @@ tuple<string, string, string> parse_arguments(int argc, char** argv)
usage(argv[0]);
exit(1);
}
if (network_name.empty()) {
network_name = file_name;
}
return make_tuple(file_name, path, network_name);
return make_tuple(file_name, path, model_name);
}
inline constexpr auto hash_conv(const std::string_view sv)
{
unsigned long hash{ 5381 };
for (unsigned char c : sv) {
hash = ((hash << 5) + hash) ^ c;
}
return hash;
}
inline constexpr auto operator"" _sh(const char* str, size_t len)
{
return hash_conv(std::string_view{ str, len });
}
pair<vector<mdlp::labels_t>, map<string, int>> discretize(vector<mdlp::samples_t>& X, mdlp::labels_t& y, vector<string> features)
{
@@ -96,39 +106,6 @@ pair<vector<mdlp::labels_t>, map<string, int>> discretize(vector<mdlp::samples_t
}
return { Xd, maxes };
}
void showNodesInfo(bayesnet::Network& network, string className)
{
cout << "Nodes:" << endl;
for (auto& node : network.getNodes()) {
auto name = node.first;
cout << "*" << node.second->getName() << " States -> " << node.second->getNumStates() << endl;
cout << "-Parents:";
for (auto parent : node.second->getParents()) {
cout << " " << parent->getName();
}
cout << endl;
cout << "-Children:";
for (auto child : node.second->getChildren()) {
cout << " " << child->getName();
}
cout << endl;
}
}
void showCPDS(bayesnet::Network& network)
{
cout << "CPDs:" << endl;
auto& nodes = network.getNodes();
for (auto it = nodes.begin(); it != nodes.end(); it++) {
cout << "* Name: " << it->first << " " << it->second->getName() << " -> " << it->second->getNumStates() << endl;
cout << "Parents: ";
for (auto parent : it->second->getParents()) {
cout << parent->getName() << " -> " << parent->getNumStates() << ", ";
}
cout << endl;
auto cpd = it->second->getCPT();
cout << cpd << endl;
}
}
bool file_exists(const std::string& name)
{
@@ -140,7 +117,7 @@ bool file_exists(const std::string& name)
}
}
pair<string, string> get_options(int argc, char** argv)
tuple<string, string, string> get_options(int argc, char** argv)
{
map<string, bool> datasets = {
{"diabetes", true},
@@ -152,58 +129,35 @@ pair<string, string> get_options(int argc, char** argv)
{"liver-disorders", true},
{"mfeat-factors", true},
};
vector <string> models = { "AODE", "KDB", "SPODE", "TAN" };
string file_name;
string path;
string network_name;
tie(file_name, path, network_name) = parse_arguments(argc, argv);
string model_name;
tie(file_name, path, model_name) = parse_arguments(argc, argv);
if (datasets.find(file_name) == datasets.end()) {
cout << "Invalid file name: " << file_name << endl;
usage(argv[0]);
exit(1);
}
file_name = path + file_name + ".arff";
if (!file_exists(file_name)) {
cout << "Data File " << file_name << " does not exist" << endl;
if (!file_exists(path + file_name + ".arff")) {
cout << "Data File " << path + file_name + ".arff" << " does not exist" << endl;
usage(argv[0]);
exit(1);
}
network_name = path + network_name + ".net";
if (!file_exists(network_name)) {
cout << "Network File " << network_name << " does not exist" << endl;
if (find(models.begin(), models.end(), model_name) == models.end()) {
cout << "Invalid model name: " << model_name << endl;
usage(argv[0]);
exit(1);
}
return { file_name, network_name };
return { file_name, path, model_name };
}
void build_network(bayesnet::Network& network, string network_name, map<string, int> maxes)
{
ifstream file(network_name);
string line;
while (getline(file, line)) {
if (line[0] == '#') {
continue;
}
istringstream iss(line);
string parent, child;
if (!(iss >> parent >> child)) {
break;
}
network.addNode(parent, maxes[parent]);
network.addNode(child, maxes[child]);
network.addEdge(parent, child);
}
file.close();
}
int main(int argc, char** argv)
{
string file_name, network_name;
tie(file_name, network_name) = get_options(argc, argv);
string file_name, path, model_name;
tie(file_name, path, model_name) = get_options(argc, argv);
auto handler = ArffFiles();
handler.load(file_name);
handler.load(path + file_name + ".arff");
// Get Dataset X, y
vector<mdlp::samples_t>& X = handler.getX();
mdlp::labels_t& y = handler.getY();
@@ -218,91 +172,54 @@ int main(int argc, char** argv)
map<string, int> maxes;
tie(Xd, maxes) = discretize(X, y, features);
maxes[className] = *max_element(y.begin(), y.end()) + 1;
cout << "Features: ";
for (auto feature : features) {
cout << "[" << feature << "] ";
}
cout << endl;
cout << "Class name: " << className << endl;
// Build Network
// auto network = bayesnet::Network(1.0);
// build_network(network, network_name, maxes);
// network.fit(Xd, y, features, className);
// cout << "Hello, Bayesian Networks!" << endl;
// showNodesInfo(network, className);
// //showCPDS(network);
// cout << "Score: " << network.score(Xd, y) << endl;
// cout << "PyTorch version: " << TORCH_VERSION << endl;
// cout << "BayesNet version: " << network.version() << endl;
// unsigned int nthreads = std::thread::hardware_concurrency();
// cout << "Computer has " << nthreads << " cores." << endl;
// cout << "****************** First ******************" << endl;
// auto metrics = bayesnet::Metrics(network.getSamples(), features, className, network.getClassNumStates());
// cout << "conditionalEdgeWeight " << endl;
// auto conditional = metrics.conditionalEdgeWeights();
// cout << conditional << endl;
// long m = features.size() + 1;
// auto matrix = torch::from_blob(conditional.data(), { m, m });
// cout << matrix << endl;
// cout << "****************** Second ******************" << endl;
// auto metrics2 = bayesnet::Metrics(Xd, y, features, className, network.getClassNumStates());
// cout << "conditionalEdgeWeight " << endl;
// auto conditional2 = metrics2.conditionalEdgeWeights();
// cout << conditional2 << endl;
// long m2 = features.size() + 1;
// auto matrix2 = torch::from_blob(conditional2.data(), { m, m });
// cout << matrix2 << endl;
cout << "****************** Preparing ******************" << endl;
map<string, vector<int>> states;
for (auto feature : features) {
states[feature] = vector<int>(maxes[feature]);
}
states[className] = vector<int>(
maxes[className]);
cout << "****************** KDB ******************" << endl;
double score;
vector<string> lines;
vector<string> graph;
auto kdb = bayesnet::KDB(2);
kdb.fit(Xd, y, features, className, states);
for (auto line : kdb.show()) {
cout << line << endl;
}
cout << "Score: " << kdb.score(Xd, y) << endl;
ofstream file("kdb.dot");
file << kdb.graph();
file.close();
cout << "****************** KDB ******************" << endl;
cout << "****************** SPODE ******************" << endl;
auto spode = bayesnet::SPODE(2);
spode.fit(Xd, y, features, className, states);
for (auto line : spode.show()) {
cout << line << endl;
}
cout << "Score: " << spode.score(Xd, y) << endl;
file.open("spode.dot");
file << spode.graph();
file.close();
cout << "****************** SPODE ******************" << endl;
cout << "****************** AODE ******************" << endl;
auto aode = bayesnet::AODE();
aode.fit(Xd, y, features, className, states);
for (auto line : aode.show()) {
cout << line << endl;
}
cout << "Score: " << aode.score(Xd, y) << endl;
file.open("aode.dot");
for (auto line : aode.graph())
file << line;
file.close();
cout << "****************** AODE ******************" << endl;
cout << "****************** TAN ******************" << endl;
auto spode = bayesnet::SPODE(2);
auto tan = bayesnet::TAN();
tan.fit(Xd, y, features, className, states);
for (auto line : tan.show()) {
switch (hash_conv(model_name)) {
case "AODE"_sh:
aode.fit(Xd, y, features, className, states);
lines = aode.show();
score = aode.score(Xd, y);
graph = aode.graph();
break;
case "KDB"_sh:
kdb.fit(Xd, y, features, className, states);
lines = kdb.show();
score = kdb.score(Xd, y);
graph = kdb.graph();
break;
case "SPODE"_sh:
spode.fit(Xd, y, features, className, states);
lines = spode.show();
score = spode.score(Xd, y);
graph = spode.graph();
break;
case "TAN"_sh:
tan.fit(Xd, y, features, className, states);
lines = tan.show();
score = tan.score(Xd, y);
graph = tan.graph();
break;
}
for (auto line : lines) {
cout << line << endl;
}
cout << "Score: " << tan.score(Xd, y) << endl;
file.open("tan.dot");
file << tan.graph();
cout << "Score: " << score << endl;
auto dot_file = model_name + "_" + file_name;
ofstream file(dot_file + ".dot");
file << graph;
file.close();
cout << "****************** TAN ******************" << endl;
cout << "Graph saved in " << model_name << "_" << file_name << ".dot" << endl;
cout << "dot -Tpng -o " + dot_file + ".png " + dot_file + ".dot " << endl;
return 0;
}

208
sample/test.cc
View File

@@ -1,208 +0,0 @@
// #include <torch/torch.h>
// int main()
// {
// torch::Tensor t = torch::rand({ 5, 5 });
// // Print original tensor
// std::cout << t << std::endl;
// // New value
// torch::Tensor new_val = torch::tensor(10.0f);
// // Indices for the cell you want to update
// auto index_i = torch::tensor({ 2 });
// auto index_j = torch::tensor({ 3 });
// // Update cell
// t.index_put_({ index_i, index_j }, new_val);
// // Print updated tensor
// std::cout << t << std::endl;
// }
#include <torch/torch.h>
#include <iostream>
#include <vector>
#include <string>
using namespace std;
double entropy(torch::Tensor feature)
{
torch::Tensor counts = feature.bincount();
int totalWeight = counts.sum().item<int>();
torch::Tensor probs = counts.to(torch::kFloat) / totalWeight;
torch::Tensor logProbs = torch::log2(probs);
torch::Tensor entropy = -probs * logProbs;
return entropy.sum().item<double>();
}
// H(Y|X) = sum_{x in X} p(x) H(Y|X=x)
double conditionalEntropy(torch::Tensor firstFeature, torch::Tensor secondFeature)
{
int numSamples = firstFeature.sizes()[0];
torch::Tensor featureCounts = secondFeature.bincount();
unordered_map<int, unordered_map<int, double>> jointCounts;
double totalWeight = 0;
for (auto i = 0; i < numSamples; i++) {
jointCounts[secondFeature[i].item<int>()][firstFeature[i].item<int>()] += 1;
totalWeight += 1;
}
if (totalWeight == 0)
throw invalid_argument("Total weight should not be zero");
double entropy = 0;
for (int value = 0; value < featureCounts.sizes()[0]; ++value) {
double p_f = featureCounts[value].item<double>() / totalWeight;
double entropy_f = 0;
for (auto& [label, jointCount] : jointCounts[value]) {
double p_l_f = jointCount / featureCounts[value].item<double>();
if (p_l_f > 0) {
entropy_f -= p_l_f * log2(p_l_f);
} else {
entropy_f = 0;
}
}
entropy += p_f * entropy_f;
}
return entropy;
}
// I(X;Y) = H(Y) - H(Y|X)
double mutualInformation(torch::Tensor firstFeature, torch::Tensor secondFeature)
{
return entropy(firstFeature) - conditionalEntropy(firstFeature, secondFeature);
}
double entropy2(torch::Tensor feature)
{
return torch::special::entr(feature).sum().item<double>();
}
int main()
{
//int i = 3, j = 1, k = 2; // Indices for the cell you want to update
// Print original tensor
// torch::Tensor t = torch::tensor({ {1, 2, 3}, {4, 5, 6} }); // 3D tensor for this example
// auto variables = vector<string>{ "A", "B" };
// auto cardinalities = vector<int>{ 5, 4 };
// torch::Tensor values = torch::rand({ 5, 4 });
// auto candidate = "B";
// vector<string> newVariables;
// vector<int> newCardinalities;
// for (int i = 0; i < variables.size(); i++) {
// if (variables[i] != candidate) {
// newVariables.push_back(variables[i]);
// newCardinalities.push_back(cardinalities[i]);
// }
// }
// torch::Tensor newValues = values.sum(1);
// cout << "original values" << endl;
// cout << values << endl;
// cout << "newValues" << endl;
// cout << newValues << endl;
// cout << "newVariables" << endl;
// for (auto& variable : newVariables) {
// cout << variable << endl;
// }
// cout << "newCardinalities" << endl;
// for (auto& cardinality : newCardinalities) {
// cout << cardinality << endl;
// }
// auto row2 = values.index({ torch::tensor(1) }); //
// cout << "row2" << endl;
// cout << row2 << endl;
// auto col2 = values.index({ "...", 1 });
// cout << "col2" << endl;
// cout << col2 << endl;
// auto col_last = values.index({ "...", -1 });
// cout << "col_last" << endl;
// cout << col_last << endl;
// values.index_put_({ "...", -1 }, torch::tensor({ 1,2,3,4,5 }));
// cout << "col_last" << endl;
// cout << col_last << endl;
// auto slice2 = values.index({ torch::indexing::Slice(1, torch::indexing::None) });
// cout << "slice2" << endl;
// cout << slice2 << endl;
// auto mask = values.index({ "...", -1 }) % 2 == 0;
// auto filter = values.index({ mask, 2 }); // Filter values
// cout << "filter" << endl;
// cout << filter << endl;
// torch::Tensor dataset = torch::tensor({ {1,0,0,1},{1,1,1,2},{0,0,0,1},{1,0,2,0},{0,0,3,0} });
// cout << "dataset" << endl;
// cout << dataset << endl;
// cout << "entropy(dataset.indices('...', 2))" << endl;
// cout << dataset.index({ "...", 2 }) << endl;
// cout << "*********************************" << endl;
// for (int i = 0; i < 4; i++) {
// cout << "datset(" << i << ")" << endl;
// cout << dataset.index({ "...", i }) << endl;
// cout << "entropy(" << i << ")" << endl;
// cout << entropy(dataset.index({ "...", i })) << endl;
// }
// cout << "......................................" << endl;
// //cout << entropy2(dataset.index({ "...", 2 }));
// cout << "conditional entropy 0 2" << endl;
// cout << conditionalEntropy(dataset.index({ "...", 0 }), dataset.index({ "...", 2 })) << endl;
// cout << "mutualInformation(dataset.index({ '...', 0 }), dataset.index({ '...', 2 }))" << endl;
// cout << mutualInformation(dataset.index({ "...", 0 }), dataset.index({ "...", 2 })) << endl;
// auto test = torch::tensor({ .1, .2, .3 }, torch::kFloat);
// auto result = torch::zeros({ 3, 3 }, torch::kFloat);
// result.index_put_({ indices }, test);
// cout << "indices" << endl;
// cout << indices << endl;
// cout << "result" << endl;
// cout << result << endl;
// cout << "Test" << endl;
// cout << torch::triu(test.reshape(3, 3), torch::kFloat)) << endl;
// Create a 3x3 tensor with zeros
torch::Tensor tensor_3x3 = torch::zeros({ 3, 3 }, torch::kFloat);
// Create a 1D tensor with the three elements you want to set in the upper corner
torch::Tensor tensor_1d = torch::tensor({ 10, 11, 12 }, torch::kFloat);
// Set the upper corner of the 3x3 tensor
auto indices = torch::triu_indices(3, 3, 1);
for (auto i = 0; i < tensor_1d.sizes()[0]; ++i) {
auto x = indices[0][i];
auto y = indices[1][i];
tensor_3x3[x][y] = tensor_1d[i];
tensor_3x3[y][x] = tensor_1d[i];
}
// Print the resulting 3x3 tensor
std::cout << tensor_3x3 << std::endl;
vector<int> v = { 1,2,3,4,5 };
torch::Tensor t = torch::tensor(v);
cout << t << endl;
// std::cout << t << std::endl;
// std::cout << "sum(0)" << std::endl;
// std::cout << t.sum(0) << std::endl;
// std::cout << "sum(1)" << std::endl;
// std::cout << t.sum(1) << std::endl;
// std::cout << "Normalized" << std::endl;
// std::cout << t / t.sum(0) << std::endl;
// New value
// torch::Tensor new_val = torch::tensor(10.0f);
// // Indices for the cell you want to update
// std::vector<torch::Tensor> indices;
// indices.push_back(torch::tensor(i)); // Replace i with your index for the 1st dimension
// indices.push_back(torch::tensor(j)); // Replace j with your index for the 2nd dimension
// indices.push_back(torch::tensor(k)); // Replace k with your index for the 3rd dimension
// //torch::ArrayRef<at::indexing::TensorIndex> indices_ref(indices);
// // Update cell
// //torch::Tensor result = torch::stack(indices);
// //torch::List<c10::optional<torch::Tensor>> indices_list = { torch::tensor(i), torch::tensor(j), torch::tensor(k) };
// torch::List<c10::optional<torch::Tensor>> indices_list;
// indices_list.push_back(torch::tensor(i));
// indices_list.push_back(torch::tensor(j));
// indices_list.push_back(torch::tensor(k));
// //t.index_put_({ torch::tensor(i), torch::tensor(j), torch::tensor(k) }, new_val);
// t.index_put_(indices_list, new_val);
// // Print updated tensor
// std::cout << t << std::endl;
}