dualtree_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 "dualtree_kde.h"
#include "dualtree_vkde.h"
#include "naive_kde.h"

void VariableBandwidthKde(Matrix &queries, Matrix &references, 
                          Matrix &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");

  if(!strcmp(fx_param_str(kde_module, "kernel", "gaussian"), "gaussian")) {
    
    Vector fast_kde_results;
    
    // for O(p^D) expansion
    if(fx_param_exists(kde_module, "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")) {
        fast_kde.PrintDebug();
      }
    }
    
    // otherwise do O(D^p) expansion
    else {
      
      printf("O(D^p) 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(true || fx_param_exists(kde_module, "fast_kde_output")) {
        fast_kde.PrintDebug();
      }
    }

    if(do_naive) {
      NaiveKde<GaussianKernel> naive_kde;
      naive_kde.Init(queries, references, reference_weights, kde_module);
      naive_kde.Compute();
      
      if(true || fx_param_exists(kde_module, "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);
    }
  }
}

void FixedBandwidthKde(Matrix &queries, Matrix &references, 
                       Matrix &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");

  if(!strcmp(fx_param_str(kde_module, "kernel", "gaussian"), "gaussian")) {
    
    Vector fast_kde_results;
    
    // for O(p^D) expansion
    if(fx_param_exists(kde_module, "multiplicative_expansion")) {
      
      printf("O(p^D) expansion KDE\n");
      DualtreeKde<GaussianKernelMultAux> 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")) {
        fast_kde.PrintDebug();
      }
    }
    
    // otherwise do O(D^p) expansion
    else {
      
      printf("O(D^p) expansion KDE\n");
      DualtreeKde<GaussianKernelAux> 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")) {
        fast_kde.PrintDebug();
      }
    }
    
    if(do_naive) {
      NaiveKde<GaussianKernel> naive_kde;
      naive_kde.Init(queries, references, reference_weights, kde_module);
      naive_kde.Compute();
      
      if(true || fx_param_exists(kde_module, "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);
    }
  }
}

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

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


  // FASTexec organizes parameters and results into submodules.  Think
  // 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");

  // The reference data file is a required parameter.
  const char* references_file_name = fx_param_str_req(fx_root, "data");

  // The query data file defaults to the references.
  const char* queries_file_name =
    fx_param_str(fx_root, "query", references_file_name);
  
  // Query and reference datasets, reference weight dataset.
  Matrix references;
  Matrix reference_weights;
  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);
  }

  // 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);
  }
  else {
    reference_weights.Init(1, references.n_cols());
    reference_weights.SetAll(1);
  }
  
  // Confirm whether the user asked for scaling of the dataset
  if(!strcmp(fx_param_str(kde_module, "scaling", "none"), "range")) {
    DatasetScaler::ScaleDataByMinMax(queries, references,
                                     queries_equal_references);
  }
  else if(!strcmp(fx_param_str(kde_module, "scaling", "none"), 
                  "standardize")) {
    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")) {
    VariableBandwidthKde(queries, references, reference_weights, 
                         queries_equal_references, kde_module);
  }
  else {
    FixedBandwidthKde(queries, references, reference_weights, 
                      queries_equal_references, kde_module);
  }

  fx_done(fx_root);
  return 0;
}