ExampleGroupStats.h

Go to the documentation of this file.

#ifndef EXAMPLEGROUPSTATSH
#define EXAMPLEGROUPSTATSH

#include "vfml.h"

typedef struct _Bin_ {
   float lowerBound, upperBound;
   float *classTotals;
   float exampleCount;
   int boundryClass;
   long boundryCount;
} Bin, *BinPtr;

BinPtr BinNew(ExampleSpecPtr spec);
void BinFree(BinPtr bin);
void BinWrite(BinPtr bin, FILE *out);

typedef struct _ContinuousTracker_ {
   ExampleSpecPtr spec;
   float *classTotals;
   long exampleCount;
   VoidListPtr bins;
   float min, max;
   int initMinMax;
   int timesPrunedCount;
   int addingNewBins;
} ContinuousTracker, *ContinuousTrackerPtr;

ContinuousTrackerPtr ContinuousTrackerNew(ExampleSpecPtr spec);
void ContinuousTrackerFree(ContinuousTrackerPtr ct);
void ContinuousTrackerAddExample(ContinuousTrackerPtr ct, 
                                    float value, int theclass);
float ContinuousTrackerGetPercentBelowThreshold(ContinuousTrackerPtr ct,
                                                      float thresh);

int ContinuousTrackerNumSplitThresholds(ContinuousTrackerPtr ct);
int ContinuousTrackerGetMostCommonClassInPartition(ContinuousTrackerPtr ct,
                        float threshold, int above);

void ContinuousTrackerEntropyAttributeSplit(ContinuousTrackerPtr ct,
                        float *firstIndex, float *firstThresh,
                        float *secondIndex, float *secondThresh);
void ContinuousTrackerGiniAttributeSplit(ContinuousTrackerPtr ct,
                        float *firstIndex, float *firstThresh,
                        float *secondIndex, float *secondThresh);

void ContinuousTrackerDisableWorseThanEntropy(ContinuousTrackerPtr ct, 
                                              float entropyThresh);
void ContinuousTrackerDisableWorseThanGini(ContinuousTrackerPtr ct, 
                                              float giniThresh);
int ContinuousTrackerPruneSplitsEntropy(ContinuousTrackerPtr ct,
                               int maxSplits, int pruneDownTo);

typedef struct _ExampleGroupStats_ {
   ExampleSpecPtr spec;
   AttributeTrackerPtr attributeTracker;

   long examplesSeen;

   long *classTotals;

   /* VoidListPtr for each attribute:
        for discrete attributes another VoidListPtr for each value, and an
                            array of longs with the count for each class 
        for continuous attributes a continuous tracker structure
   */
   VoidAListPtr stats;

} ExampleGroupStats, *ExampleGroupStatsPtr;


ExampleGroupStatsPtr ExampleGroupStatsNew(ExampleSpecPtr es, 
                                       AttributeTrackerPtr at);

void ExampleGroupStatsFree(ExampleGroupStatsPtr egs);

void ExampleGroupStatsDeactivate(ExampleGroupStatsPtr egs);

void ExampleGroupStatsReactivate(ExampleGroupStatsPtr egs);

void ExampleGroupStatsAddExample(ExampleGroupStatsPtr egs, ExamplePtr e);

void ExampleGroupStatsWrite(ExampleGroupStatsPtr egs, FILE *out);

long ExampleGroupStatsNumExamplesSeen(ExampleGroupStatsPtr egs);


AttributeTrackerPtr ExampleGroupStatsGetAttributeTracker(
                                      ExampleGroupStatsPtr egs);

int ExampleGroupStatsIsAttributeActive(ExampleGroupStatsPtr egs, int num);

void ExampleGroupStatsIgnoreAttribute(ExampleGroupStatsPtr egs, int num);


int ExampleGroupStatsGetMostCommonClassLaplace(ExampleGroupStatsPtr egs, 
                                               int addClass, int addCount);
int ExampleGroupStatsGetMostCommonClass(ExampleGroupStatsPtr egs);

long ExampleGroupStatsGetMostCommonClassCount(ExampleGroupStatsPtr egs);


int ExampleGroupStatsGetMostCommonClassForAttVal(ExampleGroupStatsPtr egs,
                                                int att, int val);

int ExampleGroupStatsIsPure(ExampleGroupStatsPtr egs);

float ExampleGroupStatsGetValuePercent(ExampleGroupStatsPtr egs, 
                                       int attNum, int valNum);
float ExampleGroupStatsGetValueGivenClassPercent(ExampleGroupStatsPtr egs, 
                                        int attNum, int valNum, int classNum);

double ExampleGroupStatsGetValueGivenClassMEstimate(ExampleGroupStatsPtr egs, 
                                        int attNum, int valNum, int classNum);

float ExampleGroupStatsGetClassPercent(ExampleGroupStatsPtr egs, int classNum);

float ExampleGroupStatsGetPercentBelowThreshold(ExampleGroupStatsPtr egs,
                                     int attNum, float thresh);

/* for naive bayes */

double ExampleGroupStatsGetValueGivenClassMEstimateLogP(ExampleGroupStatsPtr 
                             egs, int attNum, int valNum, int classNum);

double ExampleGroupStatsGetClassLogP(ExampleGroupStatsPtr egs, int classNum);


float ExampleGroupStatsEntropyTotal(ExampleGroupStatsPtr egs);

float ExampleGroupStatsEntropyDiscreteAttributeSplit(ExampleGroupStatsPtr egs,
                                                           int attNum);

float ExampleGroupStatsEntropyPlusDiscreteAttributeSplit(ExampleGroupStatsPtr 
                                 egs, int attNum, float delta);


float ExampleGroupStatsEntropyMinusDiscreteAttributeSplit(ExampleGroupStatsPtr 
                                 egs, int attNum, float delta);


void ExampleGroupStatsEntropyContinuousAttributeSplit(ExampleGroupStatsPtr egs, 
                 int attNum, float *firstIndex, float *firstThresh,
                             float *secondIndex, float *secondThresh);

float ExampleGroupStatsGiniTotal(ExampleGroupStatsPtr egs);

float ExampleGroupStatsGiniDiscreteAttributeSplit(ExampleGroupStatsPtr egs, 
                                                      int attNum);

void ExampleGroupStatsGiniContinuousAttributeSplit(ExampleGroupStatsPtr egs, 
                 int attNum, float *firstIndex, float *firstThresh,
                             float *secondIndex, float *secondThresh);

void ExampleGroupStatsIgnoreSplitsWorseThanEntropy(ExampleGroupStatsPtr egs,
                                   int attNum, float entropyThresh);

void ExampleGroupStatsIgnoreSplitsWorseThanGini(ExampleGroupStatsPtr egs,
                                                int attNum, float giniThresh);


int ExampleGroupStatsLimitSplitsEntropy(ExampleGroupStatsPtr egs, int attNum,
                               int maxSplits, int pruneDownTo);

void ExampleGroupStatsStopAddingSplits(ExampleGroupStatsPtr egs, int attNum);

int ExampleGroupStatsNumSplitThresholds(ExampleGroupStatsPtr egs, int attNum);

int ExampleGroupStatsGetMostCommonClassAboveThreshold(ExampleGroupStatsPtr egs,
                      int attNum, float threshold);
int ExampleGroupStatsGetMostCommonClassBelowThreshold(ExampleGroupStatsPtr egs,
                      int attNum, float threshold);

/* undocumented, used by CVFDT  */
void ExampleGroupStatsRemoveExample(ExampleGroupStatsPtr egs, ExamplePtr e);

#endif /* EXAMPLEGROUPSTATSH */

---

Generated for VFML by hosted by