BeliefNet.h

Go to the documentation of this file.

#ifndef BELIEFNETH
#define BELIEFNETH

#include "ExampleSpec.h"
#include "Example.h"
#include "../util/lists.h"
/*#include <stdio.h>*/

typedef struct _BeliefNetNode_ {
   int numAllocatedRows;
   int numParentCombinations;

   // indexed first by parents in order in counting order
   //  second index on value for this variable
   float **eventCounts;

   // the number of times this parent combination occured.
   float *rowCounts;

   // This is the sum of all the rowCounts;
   float numSamples;

   ExampleSpecPtr spec;
   int attributeID;

   struct _BeliefNet_ *bn;

   VoidListPtr parentIDs;
   VoidListPtr childrenIDs;
   void *userData;

   /* used internally by graph algorithms or inference algorithms,
       do not use it for things you want preserved across calls,
       use userData for that */
   void *tmpInternalData;
} BeliefNetNodeStruct, *BeliefNetNode;


//BeliefNetNode BNNodeNew(void);

void BNNodeFree(BeliefNetNode bnn);

// NOTE! Both nodes better have CPTs allocated and they better be the same
void BNNodeSetCPTFrom(BeliefNetNode target, BeliefNetNode source);

// Note: this does NOT clone user data, merely copies the pointer
BeliefNetNode BNNodeClone(BeliefNetNode bnn);

void BNNodeAddParent(BeliefNetNode bnn, BeliefNetNode parent);
//void BNNodeAddChild(BeliefNetNode bnn, BeliefNetNode child);

int BNNodeLookupParentIndex(BeliefNetNode bnn, BeliefNetNode parent);

int BNNodeLookupParentIndexByID(BeliefNetNode bnn, int id);

void BNNodeRemoveParent(BeliefNetNode bnn, int parentIndex);

BeliefNetNode BNNodeGetParent(BeliefNetNode bnn, int parentIndex);

int BNNodeGetParentID(BeliefNetNode bnn, int parentIndex);

int BNNodeGetNumParents(BeliefNetNode bnn);

int BNNodeGetNumChildren(BeliefNetNode bnn);

int BNNodeHasParent(BeliefNetNode bnn, BeliefNetNode parent);

int BNNodeHasParentID(BeliefNetNode bnn, int parentID);

void BNNodeAddValue(BeliefNetNode bnn, char *valueName);
int BNNodeLookupValue(BeliefNetNode bnn, char *valueName);

int BNNodeGetNumValues(BeliefNetNode bnn);

int BNNodeGetNumParameters(BeliefNetNode bnn);

char *BNNodeGetName(BeliefNetNode bnn);

int BNNodeStructureEqual(BeliefNetNode bnn, BeliefNetNode otherNode);


void BNNodeInitCPT(BeliefNetNode bnn);


void BNNodeZeroCPT(BeliefNetNode bnn);

void BNNodeFreeCPT(BeliefNetNode bnn);

// returns the attribute id of the node (once the node's identity is set)
int BNNodeGetID(BeliefNetNode bnn);

void BNNodeSetUserData(BeliefNetNode bnn, void *data);
//inline void *BNNodeGetUserData(BeliefNetNode bnn) {return bnn->userData;}
#define BNNodeGetUserData(bnn) (((BeliefNetNode)bnn)->userData)


void  BNNodeAddSample(BeliefNetNode bnn, ExamplePtr e);

void  BNNodeAddSamples(BeliefNetNode bnn, VoidListPtr samples);

void  BNNodeAddFractionalSample(BeliefNetNode bnn, ExamplePtr e, float weight);

void  BNNodeAddFractionalSamples(BeliefNetNode bnn, VoidListPtr samples, float weight);

float BNNodeGetCPTRowCount(BeliefNetNode bnn, ExamplePtr e);


float BNNodeGetP(BeliefNetNode bnn, int value);
void  BNNodeSetCPIndexed(BeliefNetNode bnn, int row, int value,
                                                      float probability);
float BNNodeGetCPIndexed(BeliefNetNode bnn, int row, int value);

float BNNodeGetCP(BeliefNetNode bnn, ExamplePtr e);

void  BNNodeSetCP(BeliefNetNode bnn, ExamplePtr e, float probability);

// Reset all row counts to 'strength'.  This effectively sets the confidence
//  in the current probabilities to be equal to what you would have after
//  seeing 'strength' samples which add up to the current probabilities.
//  (which may not be possible, but that's ok!)
void BNNodeSetPriorStrength(BeliefNetNode bnn, double strength);
void BNNodeSmoothProbabilities(BeliefNetNode bnn, double strength);

void BNNodeSetRandomValueGivenParents(BeliefNetNode bnn, ExamplePtr e);


float BNNodeGetNumSamples(BeliefNetNode bnn);

int BNNodeGetNumCPTRows(BeliefNetNode bnn);

typedef struct _BeliefNet_ {
   char *name;
   ExampleSpecPtr spec;
   VoidListPtr nodes;

   /* these next two contain cached values, will be 0 and -1 till filled */
   VoidListPtr topoSort;
   int hasCycle;

   void *userData;
} BeliefNetStruct, *BeliefNet;

BeliefNet BNNew(void);

void BNFree(BeliefNet bn);

BeliefNet BNClone(BeliefNet bn);

BeliefNet BNCloneNoCPTs(BeliefNet bn);

BeliefNet BNNewFromSpec(ExampleSpecPtr es);

int BNStructureEqual(BeliefNet bn, BeliefNet otherNet);

int BNGetSimStructureDifference(BeliefNet bn, BeliefNet otherNet);

void BNSetName(BeliefNet bn, char *name);

// Needed for reading and writing examples that will work with the net

ExampleSpec *BNGetExampleSpec(BeliefNet bn);

//void BNSetUserData(BeliefNet bn, int nodeID, void *data);
//void *BNGetUserData(BeliefNet bn, int nodeID);

//void BNAddNode(BeliefNet bn, BeliefNetNode bnn, char *nodeName);

BeliefNetNode BNNewNode(BeliefNet bn, char *nodeName);

/* Looks up the node by name.

This is an O(N) operation. If it isn't found returns NULL. */
BeliefNetNode BNLookupNode(BeliefNet bn, char *name);

BeliefNetNode BNGetNodeByID(BeliefNet bn, int id);

int BNGetNumNodes(BeliefNet bn);

BeliefNetNode BNGetNodeByElimOrder(BeliefNet bn, int index);

int BNHasCycle(BeliefNet bn);

void BNFlushStructureCache(BeliefNet bn);

/* \brief Calls BNNodeZeroCPT on every node in the network. */
void BNZeroCPTs(BeliefNet bn);

//void BNPrint(BeliefNet bn, FILE *out);
//void BNPrintStats(BeliefNet bn, FILE *out);

void BNAddSample(BeliefNet bn, ExamplePtr e);

void BNAddSamples(BeliefNet bn, VoidListPtr samples);

void BNAddFractionalSample(BeliefNet bn, ExamplePtr e, float weight);

void BNAddFractionalSamples(BeliefNet bn, VoidListPtr samples, float weight);

/* \brief Returns the loglikelihood of the example given the network and parameters. */
float BNGetLogLikelihood(BeliefNet bn, ExamplePtr e);

long BNGetNumIndependentParameters(BeliefNet bn);

long BNGetNumParameters(BeliefNet bn);

long BNGetMaxNodeParameters(BeliefNet bn);


ExamplePtr BNGenerateSample(BeliefNet bn);

void BNSetPriorStrength(BeliefNet bn, double strength);

void BNSmoothProbabilities(BeliefNet bn, double strength);

void BNSetUserData(BeliefNet bn, void *data);

// void *BNGetUserData(BeliefNet bn) {return bn->userData;}
#define BNGetUserData(bn) (((BeliefNet)bn)->userData)

BeliefNet BNReadBIF(char *fileName);


BeliefNet BNReadBIFFILEP(FILE *file);

void BNWriteBIF(BeliefNet bn, FILE *out);

void BNPrintStats(BeliefNet bn);




/**************************************************
  Mattr added below here and in .c.
  Geoff, if you approve, I guess move up where they belong
**************************************************/
// Allocates and fills in eventCounts and rowCounts
void BNNodeCopyCPT(BeliefNetNode bnn, float ***eventCounts, float **rowCounts);
// Restores from eventCounts and rowCounts back into the node
void BNNodeRestoreCPT(BeliefNetNode bnn, float **eventCounts, float *rowCounts);
// Just allocates
void BNNodeAllocateCPT(BeliefNetNode bnn, float ***eventCounts, float **rowCounts);
// Frees the result of one of the above two functions
void BNNodeFreeCopiedCPT(BeliefNetNode bnn, float **eventCounts, float *rowCounts);

void BNNodeRemoveParentByID(BeliefNetNode bnn, int parentID);
void BNNodeRemoveEdge(BeliefNetNode parent, BeliefNetNode child);

// If doDirichlet, then the event and rowCounts will be dirichlet parameters
//  otherwise, they will be shrunken event and rowCounts
void  BNNodeShrink(BeliefNetNode bnn, VoidListPtr data, int doDirichlet);
void BNNodeTruncateToNParents(BeliefNetNode bnn, VoidListPtr data, 
                               int maxParents);

void BNRemoveNode(BeliefNet bn, BeliefNetNode node);

void BNNodeCPTGetP(BeliefNetNode bnn, ExamplePtr e, double *p);
double BNNodeCPTGetCP(BeliefNetNode bnn, ExamplePtr e);
void BNNodeGetJointProb(BeliefNetNode parent, BeliefNetNode child, double p[2][2]);

BeliefNet BNInitLikelihoodSampling(BeliefNet bn, ExamplePtr e);

void BNAddLikelihoodSamples(BeliefNet bn, BeliefNet newNet, ExamplePtr e, int numSamples);

BeliefNet BNLikelihoodSampleNTimes(BeliefNet bn, ExamplePtr e, int numSamples);
#endif /* BELIEFNETH */

---

Generated for VFML by hosted by