VMat_maths.h

Go to the documentation of this file.

// -*- C++ -*-

// PLearn (A C++ Machine Learning Library)
// Copyright (C) 1998 Pascal Vincent
// Copyright (C) 1999-2002 Pascal Vincent, Yoshua Bengio and University of Montreal
//

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//  1. Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
// 
//  2. Redistributions in binary form must reproduce the above copyright
//     notice, this list of conditions and the following disclaimer in the
//     documentation and/or other materials provided with the distribution.
// 
//  3. The name of the authors may not be used to endorse or promote
//     products derived from this software without specific prior written
//     permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
// NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// This file is part of the PLearn library. For more information on the PLearn
// library, go to the PLearn Web site at www.plearn.org


 

/* *******************************************************      
   * $Id: VMat_maths.h,v 1.18 2004/07/21 16:30:55 chrish42 Exp $
   * This file is part of the PLearn library.
   ******************************************************* */


#ifndef VMat_maths_INC
#define VMat_maths_INC

#include <map>
#include <plearn/math/TMat.h>
#include <plearn/math/TMat_maths.h>
#include <plearn/math/StatsCollector.h>
#include <plearn/math/ConditionalStatsCollector.h>
#include "VMat.h"

namespace PLearn {
using namespace std;

class VecStatsCollector;

#define MEAN_ROW 0
#define STDDEV_ROW 1
#define MIN_ROW 2
#define MAX_ROW 3
#define NMISSING_ROW 4
#define NZERO_ROW 5
#define NPOSITIVE_ROW 6
#define NNEGATIVE_ROW 7
#define MEANPOS_ROW 8
#define STDDEVPOS_ROW 9

Mat computeBasicStats(VMat m);

TVec<StatsCollector> computeStats(VMat m, int maxnvalues, bool report_progress = true);

void computeStats(VMat m, VecStatsCollector& st, bool report_progress = true);


PP<ConditionalStatsCollector> computeConditionalStats(VMat m, int condfield, TVec<RealMapping> ranges);

void computeRowMean(VMat d, Vec& meanvec);
void computeMean(VMat d, Vec& meanvec);
void computeWeightedMean(Vec weights, VMat d, Vec& meanvec);
void computeMeanAndVariance(VMat d, Vec& meanvec, Vec& variancevec);
void computeMeanAndStddev(VMat d, Vec& meanvec, Vec& stddevvec);
void computeMeanAndCovar(VMat d, Vec& meanvec, Mat& covarmat, ostream& logstream=cerr);
void computeWeightedMeanAndCovar(Vec weights, VMat d, Vec& meanvec, Mat& covarmat);

void autocorrelation_function(const VMat& data, Mat& acf);

void computeInputMean(VMat d, Vec& meanvec);
void computeInputMeanAndCovar(VMat d, Vec& meanvec, Mat& covarmat);
void computeInputMeanAndVariance(VMat d, Vec& meanvec, Vec& var);


void computeRange(VMat d, Vec& minvec, Vec& maxvec);

real computeWeightedMeanAndCovar(VMat d, Vec& meanvec, Mat& covarmat, real threshold=0);

Array<Mat> computeConditionalMeans(VMat trainset, int targetsize, Mat& basic_stats);

VMat normalize(VMat d, Vec meanvec, Vec stddevvec);
VMat normalize(VMat d, int inputsize, int ntrain); 
inline VMat normalize(VMat d, int inputsize) { return normalize(d,inputsize,d.length()); }

VMat grep(VMat d, int col, Vec values, bool exclude=false);

map< real, int> countOccurencesInColumn(VMat m, int col);

map< real, TVec<int> > indicesOfOccurencesInColumn(VMat m, int col);

VMat grep(VMat d, int col, Vec values, const string& indexfile, bool exclude=false);

VMat filter(VMat d, const string& indexfile);

VMat shuffle(VMat d);

VMat bootstrap(VMat d, bool reorder=true, bool norepeat=true);

Mat transposeProduct(VMat m1, VMat m2);

Mat transposeProduct(VMat m);

Vec transposeProduct(VMat m1, Vec v2);

Mat productTranspose(VMat m1, VMat m2);

Mat product(Mat m1, VMat m2);

VMat transpose(VMat m1);

real linearRegression(VMat inputs, VMat outputs, real weight_decay, Mat theta_t, 
                      bool use_precomputed_XtX_XtY, Mat XtX, Mat XtY, real& sum_squared_Y,
                      bool return_squared_loss=false, int verbose_computation_every=0,
                      bool cholesky = true);
                      

Mat linearRegression(VMat inputs, VMat outputs, real weight_decay);

real weightedLinearRegression(VMat inputs, VMat outputs, VMat gammas,
                              real weight_decay, Mat theta_t, bool use_precomputed_XtX_XtY, Mat XtX,
                              Mat XtY, real& sum_squared_Y, real& sum_gammas, bool return_squared_loss=false, 
                              int verbose_computation_every=0, bool cholesky = true);

VMat rebalanceNClasses(VMat inputs, int nclasses, const string& filename);

void fullyRebalance2Classes(VMat inputs, const string& filename, bool save_indices=true);

Mat weightedLinearRegression(VMat inputs, VMat outputs, VMat gammas, real weight_decay);

VMat temporalThreshold(VMat distr, int threshold_date, bool is_before,
      int yyyymmdd_col);
VMat temporalThreshold(VMat distr, int threshold_date, bool is_before,
      int yyyy_col, int mm_col, int dd_col);

void correlations(const VMat& x, const VMat& y, Mat& r, Mat& pvalues);

void computeNearestNeighbors(VMat dataset, Vec x, TVec<int>& neighbors, int ignore_row=-1);

} // end of namespace PLearn

#endif

---