fgt_kde_main.cc

Go to the documentation of this file.

/* MLPACK 0.2
 *
 * Copyright (c) 2008, 2009 Alexander Gray,
 *                          Garry Boyer,
 *                          Ryan Riegel,
 *                          Nikolaos Vasiloglou,
 *                          Dongryeol Lee,
 *                          Chip Mappus, 
 *                          Nishant Mehta,
 *                          Hua Ouyang,
 *                          Parikshit Ram,
 *                          Long Tran,
 *                          Wee Chin Wong
 *
 * Copyright (c) 2008, 2009 Georgia Institute of Technology
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
#include <fastlib/fastlib.h>
#include "dataset_scaler.h"
#include "fgt_kde.h"
#include "naive_kde.h"

int main(int argc, char *argv[]) {

  // initialize FastExec (parameter handling stuff)
  fx_init(argc, argv, NULL);
  

  // FASTexec organizes parameters and results into submodules.  Think
  // of this as creating a new folder named "fgt_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 *fgt_kde_module =
    fx_submodule(fx_root, "kde");

  // The reference data file is a required parameter.
  const char* references_file_name = fx_param_str_req(NULL, "data");
  printf("%s\n",references_file_name);

  // The query data file defaults to the references.
  const char* queries_file_name =
    fx_param_str(NULL, "query", references_file_name);

  // query and reference datasets
  Matrix references;
  Matrix queries;

  // flag for telling whether references are equal to queries
  bool queries_equal_references =
    !strcmp(queries_file_name, references_file_name);

  // data::Load inits a matrix with the contents of a .csv or .arff.
  data::Load(references_file_name, &references);
  if(queries_equal_references) {
    queries.Alias(references);
  }
  else {
    data::Load(queries_file_name, &queries);
  }

  // confirm whether the user asked for scaling of the dataset
  if(!strcmp(fx_param_str(fgt_kde_module, "scaling", "none"), "range")) {
    DatasetScaler::ScaleDataByMinMax(queries, references,
                                     queries_equal_references);
  }

  // declare FGT-based KDE computation object and the vector holding
  // the final results
  FGTKde fgt_kde;
  Vector fgt_kde_results;

  fgt_kde.Init(queries, references, fgt_kde_module);
  fgt_kde.Compute();
  fgt_kde.get_density_estimates(&fgt_kde_results);

  // print out the results if the user specified the flag for output
  if(fx_param_exists(fgt_kde_module, "fgt_kde_output")) {
    fgt_kde.PrintDebug();
  }

  // do naive computation and compare to the FGT computations if the
  // user specified --do_naive flag
  if(fx_param_exists(fgt_kde_module, "do_naive")) {
    NaiveKde<GaussianKernel> naive_kde;
    naive_kde.Init(queries, references, fgt_kde_module);
    naive_kde.Compute();
    
    if(fx_param_exists(fgt_kde_module, "naive_kde_output")) {
      naive_kde.PrintDebug();
    }
    naive_kde.ComputeMaximumRelativeError(fgt_kde_results);
  }

  fx_done(fx_root);
  return 0;
}