kde_bandwidth_cv_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 "bandwidth_lscv.h"
#include "dataset_scaler.h"
#include "dualtree_kde.h"
#include "naive_kde.h"

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, queries.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);
  }

  // There are two options: 1) do bandwidth optimization 2) output a
  // goodness score of a given bandwidth.
  if(!strcmp(fx_param_str(kde_module, "task", "optimize"), "optimize")) {

    // Optimize bandwidth using least squares cross-validation.
    if(!strcmp(fx_param_str(kde_module, "kernel", "gaussian"), "gaussian")) {
      BandwidthLSCV::Optimize<GaussianKernelAux>(references, 
                                                 reference_weights);
    }
    else if(!strcmp(fx_param_str(kde_module, "kernel", "epan"), "epan")) {
      
      // Currently, I have not implemented the direct way to
      // cross-validate for the optimal bandwidth using the Epanechnikov
      // kernel, so I will use cross-validation using the Gaussian
      // kernel with the equivalent kernel scaling.
      BandwidthLSCV::Optimize<GaussianKernelAux>(references, 
                                                 reference_weights);
    }
  }
  else if(!strcmp(fx_param_str(kde_module, "task", "lscvscore"), 
                  "lscvscore")) {
    
    // Get the bandwidth.
    double bandwidth = fx_param_double(kde_module, "bandwidth", 0.1);

    // Optimize bandwidth using least squares cross-validation.
    if(!strcmp(fx_param_str(kde_module, "kernel", "gaussian"), "gaussian")) {
      BandwidthLSCV::ComputeLSCVScore<GaussianKernelAux>
        (references, reference_weights, bandwidth);
    }
    else if(!strcmp(fx_param_str(kde_module, "kernel", "epan"), "epan")) {
      
      // Currently, I have not implemented the direct way to
      // cross-validate for the optimal bandwidth using the Epanechnikov
      // kernel, so I will use cross-validation using the Gaussian
      // kernel with the equivalent kernel scaling.
      BandwidthLSCV::ComputeLSCVScore<GaussianKernelAux>
        (references, reference_weights, bandwidth);
    }    
  }

  fx_done(fx_root);
  return 0;
}