This page is part of an archival collection and is no longer actively maintained.

It may contain outdated information and may not meet current or future WCAG accessibility standards. We provide this content, its subpages, and associated links for historical reference only. If you need assistance, please contact support@cs.washington.edu

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