[mlpack-svn] r10051 - in mlpack/trunk/src/contrib/nslagle: kdeDL proximity_project
fastlab-svn at coffeetalk-1.cc.gatech.edu
fastlab-svn at coffeetalk-1.cc.gatech.edu
Wed Oct 26 20:35:59 EDT 2011
Author: nslagle
Date: 2011-10-26 20:35:58 -0400 (Wed, 26 Oct 2011)
New Revision: 10051
Modified:
mlpack/trunk/src/contrib/nslagle/kdeDL/dataset_scaler.h
mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_kde.h
mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_kde_common.h
mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_kde_main.cc
mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_vkde.h
mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_vkde_impl.h
mlpack/trunk/src/contrib/nslagle/kdeDL/naive_kde.h
mlpack/trunk/src/contrib/nslagle/proximity_project/general_spacetree.h
Log:
mlpack/src/contrib/nslagle: continue modifying the KDE code
Modified: mlpack/trunk/src/contrib/nslagle/kdeDL/dataset_scaler.h
===================================================================
--- mlpack/trunk/src/contrib/nslagle/kdeDL/dataset_scaler.h 2011-10-27 00:31:53 UTC (rev 10050)
+++ mlpack/trunk/src/contrib/nslagle/kdeDL/dataset_scaler.h 2011-10-27 00:35:58 UTC (rev 10051)
@@ -11,8 +11,10 @@
#define DATASET_SCALER_H
#include <mlpack/core.h>
-#include <mlpack/core/tree/bounds.h>
+#include <mlpack/core/tree/bounds.hpp>
+using namespace mlpack::math;
+
/** @brief A static class providing utilities for scaling the query
* and the reference datasets.
*
Modified: mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_kde.h
===================================================================
--- mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_kde.h 2011-10-27 00:31:53 UTC (rev 10050)
+++ mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_kde.h 2011-10-27 00:35:58 UTC (rev 10051)
@@ -65,7 +65,7 @@
#define INSIDE_DUALTREE_KDE_H
#include "mlpack/core.h"
-#include "mlpack/core/tree/spacetree.h"
+#include "mlpack/core/tree/spacetree.hpp"
//#include "contrib/nslagle/series_expansion/farfield_expansion.h"
//#include "contrib/nslagle/series_expansion/local_expansion.h"
//#include "contrib/nslagle/series_expansion/mult_farfield_expansion.h"
@@ -121,6 +121,10 @@
* fast_kde.Compute(&results);
* @endcode
*/
+
+using namespace mlpack::tree;
+using namespace mlpack::bound;
+
template<typename TKernelAux>
class DualtreeKde {
@@ -244,7 +248,7 @@
/** @brief The permutation mapping indices of references_ to
* original order.
*/
- std::vector<size_t> old_from_new_references_;
+ arma::Col<size_t> old_from_new_references_;
////////// Private Member Functions //////////
Modified: mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_kde_common.h
===================================================================
--- mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_kde_common.h 2011-10-27 00:31:53 UTC (rev 10050)
+++ mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_kde_common.h 2011-10-27 00:35:58 UTC (rev 10051)
@@ -97,7 +97,7 @@
* @param permutation The permutation.
*/
static void ShuffleAccordingToPermutation
- (arma::vec &v, const std::vector<size_t> &permutation) {
+ (arma::vec &v, const arma::Col<size_t> &permutation) {
arma::vec v_tmp(v.size());
for(size_t i = 0; i < v_tmp.size(); i++) {
Modified: mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_kde_main.cc
===================================================================
--- mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_kde_main.cc 2011-10-27 00:31:53 UTC (rev 10050)
+++ mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_kde_main.cc 2011-10-27 00:35:58 UTC (rev 10051)
@@ -6,33 +6,36 @@
*/
#include "mlpack/core.h"
+#include "mlpack/core/kernels/gaussian_kernel.hpp"
#include "dataset_scaler.h"
#include "dualtree_kde.h"
#include "dualtree_vkde.h"
#include "naive_kde.h"
-void VariableBandwidthKde(Matrix &queries, Matrix &references,
- Matrix &reference_weights,
+using namespace mlpack::kernel;
+
+void VariableBandwidthKde(arma::mat &queries, arma::mat &references,
+ arma::mat &reference_weights,
bool queries_equal_references,
struct datanode *kde_module) {
// flag for determining whether to compute naively
- bool do_naive = fx_param_exists(kde_module, "do_naive");
+ bool do_naive = CLI::HasParam("do_naive");
- if(!strcmp(fx_param_str(kde_module, "kernel", "gaussian"), "gaussian")) {
-
- Vector fast_kde_results;
-
+ if(!strcmp(CLI::GetParam<std::string>("kernel").c_str(), "gaussian")) {
+
+ arma::vec fast_kde_results;
+
// for O(p^D) expansion
- if(fx_param_exists(kde_module, "multiplicative_expansion")) {
-
+ if(CLI::HasParam("multiplicative_expansion")) {
+
printf("O(p^D) expansion KDE\n");
DualtreeVKde<GaussianKernel> fast_kde;
fast_kde.Init(queries, references, reference_weights,
queries_equal_references, kde_module);
fast_kde.Compute(&fast_kde_results);
-
- if(fx_param_exists(kde_module, "fast_kde_output")) {
+
+ if(CLI::HasParam("fast_kde_output")) {
fast_kde.PrintDebug();
}
}
@@ -46,7 +49,7 @@
queries_equal_references, kde_module);
fast_kde.Compute(&fast_kde_results);
- if(true || fx_param_exists(kde_module, "fast_kde_output")) {
+ if(true || CLI::HasParam("fast_kde_output")) {
fast_kde.PrintDebug();
}
}
@@ -56,59 +59,59 @@
naive_kde.Init(queries, references, reference_weights, kde_module);
naive_kde.Compute();
- if(true || fx_param_exists(kde_module, "naive_kde_output")) {
+ if(true || CLI::HasParam("naive_kde_output")) {
naive_kde.PrintDebug();
}
naive_kde.ComputeMaximumRelativeError(fast_kde_results);
}
}
- else if(!strcmp(fx_param_str(kde_module, "kernel", "epan"), "epan")) {
- DualtreeVKde<EpanKernel> fast_kde;
- Vector fast_kde_results;
-
- fast_kde.Init(queries, references, reference_weights,
- queries_equal_references, kde_module);
- fast_kde.Compute(&fast_kde_results);
-
- if(fx_param_exists(kde_module, "fast_kde_output")) {
- fast_kde.PrintDebug();
- }
-
- if(do_naive) {
- NaiveKde<EpanKernel> naive_kde;
- naive_kde.Init(queries, references, reference_weights, kde_module);
- naive_kde.Compute();
-
- if(fx_param_exists(kde_module, "naive_kde_output")) {
- naive_kde.PrintDebug();
- }
- naive_kde.ComputeMaximumRelativeError(fast_kde_results);
- }
- }
+// else if(!strcmp(CLI::GetParam<std::string>("kernel").c_str(), "epan")) {
+// DualtreeVKde<EpanKernel> fast_kde;
+// arma::vec fast_kde_results;
+//
+// fast_kde.Init(queries, references, reference_weights,
+// queries_equal_references, kde_module);
+// fast_kde.Compute(&fast_kde_results);
+//
+// if(CLI::HasParam("fast_kde_output")) {
+// fast_kde.PrintDebug();
+// }
+//
+// if(do_naive) {
+// NaiveKde<EpanKernel> naive_kde;
+// naive_kde.Init(queries, references, reference_weights, kde_module);
+// naive_kde.Compute();
+//
+// if(CLI::HasParam("naive_kde_output")) {
+// naive_kde.PrintDebug();
+// }
+// naive_kde.ComputeMaximumRelativeError(fast_kde_results);
+// }
+// }
}
-void FixedBandwidthKde(Matrix &queries, Matrix &references,
- Matrix &reference_weights,
+void FixedBandwidthKde(arma::mat &queries, arma::mat &references,
+ arma::mat &reference_weights,
bool queries_equal_references,
struct datanode *kde_module) {
// flag for determining whether to compute naively
- bool do_naive = fx_param_exists(kde_module, "do_naive");
+ bool do_naive = CLI::HasParam("do_naive");
- if(!strcmp(fx_param_str(kde_module, "kernel", "gaussian"), "gaussian")) {
+ if(!strcmp(CLI::GetParam<std::string>("kernel").c_str(), "gaussian")) {
- Vector fast_kde_results;
+ arma::vec fast_kde_results;
// for O(p^D) expansion
- if(fx_param_exists(kde_module, "multiplicative_expansion")) {
+ if(CLI::HasParam("multiplicative_expansion")) {
printf("O(p^D) expansion KDE\n");
- DualtreeKde<GaussianKernelMultAux> fast_kde;
+ DualtreeKde<kernel::GaussianKernel> fast_kde;
fast_kde.Init(queries, references, reference_weights,
queries_equal_references, kde_module);
fast_kde.Compute(&fast_kde_results);
- if(fx_param_exists(kde_module, "fast_kde_output")) {
+ if(CLI::HasParam("fast_kde_output")) {
fast_kde.PrintDebug();
}
}
@@ -117,12 +120,12 @@
else {
printf("O(D^p) expansion KDE\n");
- DualtreeKde<GaussianKernelAux> fast_kde;
+ DualtreeKde<kernel::GaussianKernel> fast_kde;
fast_kde.Init(queries, references, reference_weights,
queries_equal_references, kde_module);
fast_kde.Compute(&fast_kde_results);
- if(true || fx_param_exists(kde_module, "fast_kde_output")) {
+ if(true || CLI::HasParam("fast_kde_output")) {
fast_kde.PrintDebug();
}
}
@@ -132,36 +135,36 @@
naive_kde.Init(queries, references, reference_weights, kde_module);
naive_kde.Compute();
- if(true || fx_param_exists(kde_module, "naive_kde_output")) {
+ if(true || CLI::HasParam("naive_kde_output")) {
naive_kde.PrintDebug();
}
naive_kde.ComputeMaximumRelativeError(fast_kde_results);
}
-
- }
- else if(!strcmp(fx_param_str(kde_module, "kernel", "epan"), "epan")) {
- DualtreeKde<EpanKernelAux> fast_kde;
- Vector fast_kde_results;
- fast_kde.Init(queries, references, reference_weights,
- queries_equal_references, kde_module);
- fast_kde.Compute(&fast_kde_results);
-
- if(fx_param_exists(kde_module, "fast_kde_output")) {
- fast_kde.PrintDebug();
- }
-
- if(do_naive) {
- NaiveKde<EpanKernel> naive_kde;
- naive_kde.Init(queries, references, reference_weights, kde_module);
- naive_kde.Compute();
-
- if(fx_param_exists(kde_module, "naive_kde_output")) {
- naive_kde.PrintDebug();
- }
- naive_kde.ComputeMaximumRelativeError(fast_kde_results);
- }
}
+// else if(!strcmp(CLI::GetParam<std::string>("kernel").c_str(), "epan")) {
+// DualtreeKde<EpanKernelAux> fast_kde;
+// arma::vec fast_kde_results;
+//
+// fast_kde.Init(queries, references, reference_weights,
+// queries_equal_references, kde_module);
+// fast_kde.Compute(&fast_kde_results);
+//
+// if(CLI::HasParam("fast_kde_output")) {
+// fast_kde.PrintDebug();
+// }
+//
+// if(do_naive) {
+// NaiveKde<EpanKernel> naive_kde;
+// naive_kde.Init(queries, references, reference_weights, kde_module);
+// naive_kde.Compute();
+//
+// if(CLI::HasParam("naive_kde_output")) {
+// naive_kde.PrintDebug();
+// }
+// naive_kde.ComputeMaximumRelativeError(fast_kde_results);
+// }
+// }
}
/**
@@ -237,7 +240,7 @@
int main(int argc, char *argv[]) {
// initialize FastExec (parameter handling stuff)
- fx_init(argc, argv, &kde_main_doc);
+ CLI::ParseCommandLine(argc, argv);
////////// READING PARAMETERS AND LOADING DATA /////////////////////
@@ -245,56 +248,56 @@
// of this as creating a new folder named "kde_module" under the
// root directory (NULL) for the Kde object to work inside. Here,
// we initialize it with all parameters defined "--kde/...=...".
- struct datanode* kde_module = fx_submodule(fx_root, "kde");
+ struct datanode* kde_module = NULL;
// The reference data file is a required parameter.
- const char* references_file_name = fx_param_str_req(fx_root, "data");
+ std::string references_file_name = CLI::GetParam<std::string>("data");
// The query data file defaults to the references.
- const char* queries_file_name =
- fx_param_str(fx_root, "query", references_file_name);
+ std::string queries_file_name =
+ CLI::GetParam<std::string>("query");
// Query and reference datasets, reference weight dataset.
- Matrix references;
- Matrix reference_weights;
- Matrix queries;
+ arma::mat references;
+ arma::mat reference_weights;
+ arma::mat queries;
// Flag for telling whether references are equal to queries
bool queries_equal_references =
- !strcmp(queries_file_name, references_file_name);
+ !strcmp(queries_file_name.c_str(), references_file_name.c_str());
- // data::Load inits a matrix with the contents of a .csv or .arff.
- data::Load(references_file_name, &references);
+ // data::Load inits a arma::mat with the contents of a .csv or .arff.
+ data::Load(references_file_name.c_str(), references);
if(queries_equal_references) {
- queries.Alias(references);
+ queries = references;
}
else {
- data::Load(queries_file_name, &queries);
+ data::Load(queries_file_name.c_str(), queries);
}
// If the reference weight file name is specified, then read in,
// otherwise, initialize to uniform weights.
- if(fx_param_exists(fx_root, "dwgts")) {
- data::Load(fx_param_str(fx_root, "dwgts", NULL), &reference_weights);
+ if(CLI::HasParam("dwgts")) {
+ data::Load(CLI::GetParam<std::string>("dwgts").c_str(), reference_weights);
}
else {
- reference_weights.Init(1, references.n_cols());
- reference_weights.SetAll(1);
+ reference_weights = arma::mat(1, references.n_cols);
+ reference_weights.fill(1);
}
-
+
// Confirm whether the user asked for scaling of the dataset
- if(!strcmp(fx_param_str(kde_module, "scaling", "none"), "range")) {
+ if(!strcmp(CLI::GetParam<std::string>("scaling").c_str(), "range")) {
DatasetScaler::ScaleDataByMinMax(queries, references,
queries_equal_references);
}
- else if(!strcmp(fx_param_str(kde_module, "scaling", "none"),
+ else if(!strcmp(CLI::GetParam<std::string>("scaling").c_str(),
"standardize")) {
- DatasetScaler::StandardizeData(queries, references,
+ DatasetScaler::StandardizeData(queries, references,
queries_equal_references);
}
// By default, we want to run the fixed-bandwidth KDE.
- if(!strcmp(fx_param_str(kde_module, "mode", "fixedbw"), "variablebw")) {
+ if(!strcmp(CLI::GetParam<std::string>("mode").c_str(), "variablebw")) {
VariableBandwidthKde(queries, references, reference_weights,
queries_equal_references, kde_module);
}
@@ -303,6 +306,5 @@
queries_equal_references, kde_module);
}
- fx_done(fx_root);
return 0;
}
Modified: mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_vkde.h
===================================================================
--- mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_vkde.h 2011-10-27 00:31:53 UTC (rev 10050)
+++ mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_vkde.h 2011-10-27 00:35:58 UTC (rev 10051)
@@ -61,7 +61,7 @@
#define INSIDE_DUALTREE_VKDE_H
#include "mlpack/core.h"
-#include "mlpack/core/tree/spacetree.h"
+#include "mlpack/core/tree/spacetree.hpp"
//#include "contrib/dongryel/proximity_project/gen_metric_tree.h"
//#include "dualtree_kde_common.h"
//#include "kde_stat.h"
@@ -196,12 +196,12 @@
/** @brief The permutation mapping indices of queries_ to original
* order.
*/
- std::vector<size_t> old_from_new_queries_;
+ arma::Col<size_t> old_from_new_queries_;
/** @brief The permutation mapping indices of references_ to
* original order.
*/
- std::vector<size_t> old_from_new_references_;
+ arma::Col<size_t> old_from_new_references_;
////////// Private Member Functions //////////
@@ -393,7 +393,7 @@
// the reference tree.
CLI::StartTimer("tree_d");
rroot_ = proximity::MakeGenMetricTree<Tree>(rset_, leaflen,
- &old_from_new_references_,
+ old_from_new_references_,
NULL);
DualtreeKdeCommon::ShuffleAccordingToPermutation
(rset_weights_, old_from_new_references_);
@@ -404,35 +404,34 @@
}
else {
qroot_ = proximity::MakeGenMetricTree<Tree>(qset_, leaflen,
- &old_from_new_queries_,
+ &old_from_new_queries_,
NULL);
}
CLI::StopTimer("tree_d");
-
+
// Initialize the density lists
- densities_l_ = arma::vec(qset_.n_cols());
- densities_e_ = arma::vec(qset_.n_cols());
- densities_u_ = arma::vec(qset_.n_cols());
+ densities_l_ = arma::vec(qset_.n_cols);
+ densities_e_ = arma::vec(qset_.n_cols);
+ densities_u_ = arma::vec(qset_.n_cols);
// Initialize the error accounting stuff.
- used_error_ = arma::vec(qset_.n_cols());
- n_pruned_ = arma::vec(qset_.n_cols());
+ used_error_ = arma::vec(qset_.n_cols);
+ n_pruned_ = arma::vec(qset_.n_cols);
// Initialize the kernels for each reference point.
int knns = CLI::GetParam<int>("knn");
- AllkNN all_knn;
+ AllkNN all_knn = AllkNN(rset_, 20);
kernels_.Init(rset_.n_cols());
- all_knn.Init(rset_, 20, knns);
- std::vector<size_t> resulting_neighbors;
- std::vector<double> squared_distances;
+ arma::Mat<size_t> resulting_neighbors;
+ arma::mat squared_distances;
- fx_timer_start(fx_root, "bandwidth_initialization");
- all_knn.ComputeNeighbors(&resulting_neighbors, &squared_distances);
+ CLI::StartTimer("bandwidth_initialization");
+ all_knn.ComputeNeighbors(resulting_neighbors, squared_distances);
for(size_t i = 0; i < squared_distances.size(); i += knns) {
kernels_[i / knns].Init(sqrt(squared_distances[i + knns - 1]));
}
- fx_timer_stop(fx_root, "bandwidth_initialization");
+ CLI::StopTimer("bandwidth_initialization");
// Renormalize the reference weights according to the bandwidths
// that have been chosen.
@@ -455,14 +454,14 @@
FILE *stream = stdout;
const char *fname = NULL;
- if((fname = fx_param_str(module_, "fast_kde_output",
- "fast_kde_output.txt")) != NULL) {
+ if((fname = CLI::GetParam<std::string>("fast_kde_output")) != NULL)
+ {
stream = fopen(fname, "w+");
}
for(size_t q = 0; q < qset_.n_cols(); q++) {
fprintf(stream, "%g\n", densities_e_[q]);
}
-
+
if(stream != stdout) {
fclose(stream);
}
Modified: mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_vkde_impl.h
===================================================================
--- mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_vkde_impl.h 2011-10-27 00:31:53 UTC (rev 10050)
+++ mlpack/trunk/src/contrib/nslagle/kdeDL/dualtree_vkde_impl.h 2011-10-27 00:35:58 UTC (rev 10051)
@@ -13,20 +13,20 @@
qnode->stat().ResetBoundStatistics();
// Compute unnormalized sum for each query point.
- for(index_t q = qnode->begin(); q < qnode->end(); q++) {
+ for(size_t q = qnode->begin(); q < qnode->end(); q++) {
// Incorporate the postponed information.
DualtreeKdeCommon::AddPostponed(qnode, q, this);
// Get the query point.
- const double *q_col = qset_.GetColumnPtr(q);
- for(index_t r = rnode->begin(); r < rnode->end(); r++) {
+ const arma::vec q_col = qset_.unsafe_col(q);
+ for(size_t r = rnode->begin(); r < rnode->end(); r++) {
// Get the reference point.
- const double *r_col = rset_.GetColumnPtr(r);
+ const arma::vec r_col = rset_.unsafe_col(r);
// pairwise distance and kernel value
- double dsqd = la::DistanceSqEuclidean(qset_.n_rows(), q_col, r_col);
+ double dsqd = kernel::LMetric<2,false>::Evaluate (q_col, r_col);
double kernel_value = kernels_[r].EvalUnnormOnSq(dsqd);
double weighted_kernel_value = rset_weights_[r] * kernel_value;
@@ -53,7 +53,7 @@
}
template<typename TKernel>
-double DualtreeVKde<TKernel>::EvalUnnormOnSq_(index_t reference_point_index,
+double DualtreeVKde<TKernel>::EvalUnnormOnSq_(size_t reference_point_index,
double squared_distance) {
return kernels_[reference_point_index].
EvalUnnormOnSq(squared_distance);
@@ -70,8 +70,8 @@
double used_error = 0, n_pruned = 0;
// temporary variable for holding distance/kernel value bounds
- DRange dsqd_range;
- DRange kernel_value_range;
+ Range dsqd_range;
+ Range kernel_value_range;
// First compute distance/kernel value bounds.
dsqd_range.lo = qnode->bound().MinDistanceSq(rnode->bound());
@@ -278,7 +278,7 @@
node->stat().weight_sum_ = 0;
// Reset the minimum/maximum bandwidths owned by the node.
- for(index_t i = node->begin(); i < node->end(); i++) {
+ for(size_t i = node->begin(); i < node->end(); i++) {
node->stat().min_bandwidth_kernel_.Init
(std::min(sqrt(node->stat().min_bandwidth_kernel_.bandwidth_sq()),
sqrt(kernels_[i].bandwidth_sq())));
@@ -303,7 +303,7 @@
// we can refine it to better bounds.
qstat.ResetBoundStatistics();
- for(index_t q = qnode->begin(); q < qnode->end(); q++) {
+ for(size_t q = qnode->begin(); q < qnode->end(); q++) {
// Add all postponed quantities.
DualtreeKdeCommon::AddPostponed(qnode, q, this);
Modified: mlpack/trunk/src/contrib/nslagle/kdeDL/naive_kde.h
===================================================================
--- mlpack/trunk/src/contrib/nslagle/kdeDL/naive_kde.h 2011-10-27 00:31:53 UTC (rev 10050)
+++ mlpack/trunk/src/contrib/nslagle/kdeDL/naive_kde.h 2011-10-27 00:35:58 UTC (rev 10051)
@@ -32,7 +32,7 @@
template<typename TKernel>
class NaiveKde {
- FORBID_ACCIDENTAL_COPIES(NaiveKde);
+ //FORBID_ACCIDENTAL_COPIES(NaiveKde);
private:
@@ -42,19 +42,19 @@
struct datanode *module_;
/** @brief The column-oriented query dataset. */
- Matrix qset_;
+ arma::mat qset_;
/** @brief The column-oriented reference dataset. */
- Matrix rset_;
+ arma::mat rset_;
/** @brief The vector containing the reference set weights. */
- Vector rset_weights_;
+ arma::vec rset_weights_;
/** @brief The kernel function. */
- ArrayList<TKernel> kernels_;
+ std::vector<TKernel> kernels_;
/** @brief The computed densities. */
- Vector densities_;
+ arma::vec densities_;
/** @brief The normalizing constant. */
double norm_const_;
@@ -78,10 +78,10 @@
* @param results An uninitialized vector which will be initialized
* with the computed density estimates.
*/
- void get_density_estimates(Vector *results) {
- results->Init(densities_.length());
+ void get_density_estimates(arma::vec *results) {
+ *results = arma::vec(densities_.size());
- for(index_t i = 0; i < densities_.length(); i++) {
+ for(size_t i = 0; i < densities_.size(); i++) {
(*results)[i] = densities_[i];
}
}
@@ -93,19 +93,19 @@
* @param results An uninitialized vector which will be initialized
* with the computed density estimates.
*/
- void Compute(Vector *results) {
+ void Compute(arma::vec *results) {
printf("\nStarting naive KDE...\n");
- fx_timer_start(module_, "naive_kde_compute");
+ CLI::StartTimer("naive_kde_compute");
- for(index_t q = 0; q < qset_.n_cols(); q++) {
+ for(size_t q = 0; q < qset_.n_cols(); q++) {
- const double *q_col = qset_.GetColumnPtr(q);
+ const arma::vec q_col = qset_.unsafe_col(q);
// Compute unnormalized sum first.
- for(index_t r = 0; r < rset_.n_cols(); r++) {
- const double *r_col = rset_.GetColumnPtr(r);
- double dsqd = la::DistanceSqEuclidean(qset_.n_rows(), q_col, r_col);
+ for(size_t r = 0; r < rset_.n_cols(); r++) {
+ const arma::vec r_col = rset_.unsafe_col(r);
+ double dsqd = kernel::LMetric<2,false>::Evaluate(q_col, r_col);
densities_[q] += rset_weights_[r] * kernels_[r].EvalUnnormOnSq(dsqd);
}
@@ -113,7 +113,7 @@
// Then normalize it.
densities_[q] /= norm_const_;
}
- fx_timer_stop(module_, "naive_kde_compute");
+ CLI::StopTimer("naive_kde_compute");
printf("\nNaive KDE completed...\n");
// retrieve density estimates
@@ -125,32 +125,31 @@
void Compute() {
printf("\nStarting naive KDE...\n");
- fx_timer_start(module_, "naive_kde_compute");
+ CLI::StartTimer("naive_kde_compute");
- for(index_t q = 0; q < qset_.n_cols(); q++) {
+ for(size_t q = 0; q < qset_.n_cols(); q++) {
- const double *q_col = qset_.GetColumnPtr(q);
+ const arma::vec q_col = qset_.unsafe_col(q);
// Compute unnormalized sum.
- for(index_t r = 0; r < rset_.n_cols(); r++) {
- const double *r_col = rset_.GetColumnPtr(r);
- double dsqd = la::DistanceSqEuclidean(qset_.n_rows(), q_col, r_col);
+ for(size_t r = 0; r < rset_.n_cols(); r++) {
+ const arma::vec r_col = rset_.unsafe_col(r);
+ double dsqd = kernel::LMetric<2,false>::Evaluate (q_col, r_col);
densities_[q] += rset_weights_[r] * kernels_[r].EvalUnnormOnSq(dsqd);
}
// Then, normalize it.
densities_[q] /= norm_const_;
}
- fx_timer_stop(module_, "naive_kde_compute");
+ CLI::StopTimer("naive_kde_compute");
printf("\nNaive KDE completed...\n");
}
- void Init(Matrix &qset, Matrix &rset, struct datanode *module_in) {
+ void Init(arma::mat &qset, arma::mat &rset, struct datanode *module_in) {
// Use the uniform weights for a moment.
- Matrix uniform_weights;
- uniform_weights.Init(1, rset.n_cols());
- uniform_weights.SetAll(1.0);
+ arma::mat uniform_weights(1, rset.n_cols());
+ uniform_weights.fill(1.0);
Init(qset, rset, uniform_weights, module_in);
}
@@ -162,53 +161,67 @@
* @param rset The column-oriented reference dataset.
* @param module_in The module holding the parameters.
*/
- void Init(Matrix &qset, Matrix &rset, Matrix &reference_weights,
+ void Init(arma::mat &qset, arma::mat &rset, arma::mat &reference_weights,
struct datanode *module_in) {
// Set the datanode module to be the incoming one.
module_ = module_in;
// Get datasets.
- qset_.Copy(qset);
- rset_.Copy(rset);
- rset_weights_.Init(reference_weights.n_cols());
- for(index_t i = 0; i < rset_weights_.length(); i++) {
- rset_weights_[i] = reference_weights.get(0, i);
- }
+ qset_ = arma::mat(qset.n_rows, qset.n_cols);
+ for (size_t c = 0; c < qset.n_cols; ++c)
+ {
+ for (size_t r = 0; r < qset.n_rows; ++r)
+ {
+ qset_(r,c) = qset(r,c);
+ }
+ }
+ rset_ = arma::mat(rset.n_rows, rset.n_cols);
+ for (size_t c = 0; c < rset.n_cols; ++c)
+ {
+ for (size_t r = 0; r < rset.n_rows; ++r)
+ {
+ rset_(r,c) = rset(r,c);
+ }
+ }
+ rset_weights_ = arma::vec(reference_weights.n_cols());
+ for(size_t i = 0; i < rset_weights_.size(); i++)
+ {
+ rset_weights_[i] = reference_weights(0, i);
+ }
// Compute the normalizing constant.
double weight_sum = 0;
- for(index_t i = 0; i < rset_weights_.length(); i++) {
+ for(size_t i = 0; i < rset_weights_.size(); i++) {
weight_sum += rset_weights_[i];
}
-
+
// Get bandwidth and compute the normalizing constant.
kernels_.Init(rset_.n_cols());
- if(!strcmp(fx_param_str(module_, "mode", "variablebw"), "variablebw")) {
+ if(!strcmp(CLI::GetParam<std::string>("mode").c_str(), "variablebw")) {
// Initialize the kernels for each reference point.
- int knns = fx_param_int_req(module_, "knn");
- AllkNN all_knn;
- all_knn.Init(rset_, 20, knns);
- ArrayList<index_t> resulting_neighbors;
- ArrayList<double> squared_distances;
-
- fx_timer_start(fx_root, "bandwidth_initialization");
- all_knn.ComputeNeighbors(&resulting_neighbors, &squared_distances);
-
- for(index_t i = 0; i < squared_distances.size(); i += knns) {
+ int knns = CLI::GetParam<int>("knn");
+ AllkNN all_knn = AllkNN(rset_, 20, knns);
+ arma::Mat<size_t> resulting_neighbors;
+ arma::mat squared_distances;
+
+ CLI::StartTimer("bandwidth_initialization");
+ all_knn.ComputeNeighbors(resulting_neighbors, squared_distances);
+
+ for(size_t i = 0; i < squared_distances.size(); i += knns) {
kernels_[i / knns].Init(sqrt(squared_distances[i + knns - 1]));
}
- fx_timer_stop(fx_root, "bandwidth_initialization");
+ CLI::StopTimer("bandwidth_initialization");
// Renormalize the reference weights according to the bandwidths
// that have been chosen.
double min_norm_const = DBL_MAX;
- for(index_t i = 0; i < rset_weights_.length(); i++) {
+ for(size_t i = 0; i < rset_weights_.size(); i++) {
double norm_const = kernels_[i].CalcNormConstant(qset_.n_rows());
min_norm_const = std::min(min_norm_const, norm_const);
}
- for(index_t i = 0; i < rset_weights_.length(); i++) {
+ for(size_t i = 0; i < rset_weights_.size(); i++) {
double norm_const = kernels_[i].CalcNormConstant(qset_.n_rows());
rset_weights_[i] *= (min_norm_const / norm_const);
}
@@ -217,15 +230,15 @@
norm_const_ = weight_sum * min_norm_const;
}
else {
- for(index_t i = 0; i < kernels_.size(); i++) {
- kernels_[i].Init(fx_param_double_req(module_, "bandwidth"));
+ for(size_t i = 0; i < kernels_.size(); i++) {
+ kernels_[i].Init(CLI::GetParam<double>("bandwidth"));
}
norm_const_ = kernels_[0].CalcNormConstant(qset_.n_rows()) * weight_sum;
}
// Allocate density storage.
- densities_.Init(qset.n_cols());
- densities_.SetZero();
+ densities_ = arma::vec(qset.n_cols());
+ densities_.zeros();
}
/** @brief Output KDE results to a stream
@@ -241,11 +254,10 @@
const char *fname = NULL;
{
- fname = fx_param_str(module_, "naive_kde_output",
- "naive_kde_output.txt");
+ fname = CLI::GetParam<std::string>("naive_kde_output");
stream = fopen(fname, "w+");
}
- for(index_t q = 0; q < qset_.n_cols(); q++) {
+ for(size_t q = 0; q < qset_.n_cols(); q++) {
fprintf(stream, "%g\n", densities_[q]);
}
@@ -263,13 +275,13 @@
* @param density_estimates The vector holding approximated density
* estimates.
*/
- void ComputeMaximumRelativeError(const Vector &density_estimates) {
+ void ComputeMaximumRelativeError(const arma::vec &density_estimates) {
double max_rel_err = 0;
FILE *stream = fopen("relative_error_output.txt", "w+");
int within_limit = 0;
- for(index_t q = 0; q < densities_.length(); q++) {
+ for(size_t q = 0; q < densities_.size(); q++) {
double rel_err = (fabs(density_estimates[q] - densities_[q]) <
DBL_EPSILON) ?
0:fabs(density_estimates[q] - densities_[q]) /
@@ -277,13 +289,13 @@
if(isnan(density_estimates[q]) || isinf(density_estimates[q]) ||
isnan(densities_[q]) || isinf(densities_[q])) {
- VERBOSE_MSG(0,"Warning: Got infs or nans!\n");
+ Log::Info << "Warning: Got infs or nans!";
}
if(rel_err > max_rel_err) {
max_rel_err = rel_err;
}
- if(rel_err <= fx_param_double(module_, "relative_error", 0.01)) {
+ if(rel_err <= CLI::GetParam<double>("relative_error")) {
within_limit++;
}
@@ -291,10 +303,10 @@
}
fclose(stream);
- fx_format_result(module_, "maximum_relative_error_for_fast_KDE", "%g",
- max_rel_err);
- fx_format_result(module_, "under_relative_error_limit", "%d",
- within_limit);
+ //fx_format_result(module_, "maximum_relative_error_for_fast_KDE", "%g",
+ // max_rel_err);
+ //fx_format_result(module_, "under_relative_error_limit", "%d",
+ // within_limit);
}
};
Modified: mlpack/trunk/src/contrib/nslagle/proximity_project/general_spacetree.h
===================================================================
--- mlpack/trunk/src/contrib/nslagle/proximity_project/general_spacetree.h 2011-10-27 00:31:53 UTC (rev 10050)
+++ mlpack/trunk/src/contrib/nslagle/proximity_project/general_spacetree.h 2011-10-27 00:35:58 UTC (rev 10051)
@@ -12,7 +12,7 @@
#define TREE_GENERAL_SPACETREE_H
#include <mlpack/core.h>
-#include "mlpack/core/tree/statistic.h"
+#include "mlpack/core/tree/statistic.hpp"
#define _lineStr(x) # x
#define lineStr(x) _lineStr(x)
More information about the mlpack-svn
mailing list