vfbn1.c

数据挖掘方面的源码

            DebugMessage(1, 4, "Do none above bound\n");
            qsort(probs, BNNodeGetNumValues(bnn), sizeof(double),
                                          _SortDoublesCompare);

            if(numCPTRows == 1) {
               /* know pij must == 1.0 */
               data->lowerBound += _GetMinPLgPCPTRowSum(bnn, probs, 
                               1.0, pijkEpsilon);
               data->upperBound += _GetMaxPLgPCPTRowSum(bnn, probs, 
                               1.0, pijkEpsilon);
            } else {
               data->lowerBound += _GetMinPLgPCPTRowSum(bnn, probs, 
                               min(pij + pijEpsilon, 1.0), pijkEpsilon);
               data->upperBound += _GetMaxPLgPCPTRowSum(bnn, probs, 
                               max(pij - pijEpsilon, 0), pijkEpsilon);
            }

         } else if(canOptimizeOneAbove == 1) {
            DebugMessage(1, 4, "Do one above bound\n");

            qsort(probs, BNNodeGetNumValues(bnn), sizeof(double),
                                          _SortDoublesCompare);
            if(numCPTRows == 1) {
               /* know pij must == 1.0 */
               data->lowerBound += _GetMinPLgPCPTRowSumOneAbove(bnn, probs, 
                               1.0, pijkEpsilon);
               data->upperBound += _GetMaxPLgPCPTRowSumOneAbove(bnn, probs, 
                               1.0, pijkEpsilon);
            } else {
               data->lowerBound += _GetMinPLgPCPTRowSumOneAbove(bnn, probs, 
                               min(pij + pijEpsilon, 1.0), pijkEpsilon);
               data->upperBound += _GetMaxPLgPCPTRowSumOneAbove(bnn, probs, 
                               max(pij - pijEpsilon, 0), pijkEpsilon);
            }

         } else {
            DebugMessage(1, 4, "Do bad bound\n");

            for(k = 0 ; k < BNNodeGetNumValues(bnn) ; k++) {
               data->upperBound += _MaxPLgP(prob, bnn->rowCounts[j]);
               data->lowerBound += _MinPLgP(prob, bnn->rowCounts[j]);
            }
         }  
      }

      if(data->upperBound > 0) {
         data->upperBound = 0;
      }

      MFreePtr(probs);
   }
}

static void _UpdateCurrentNetScore(BeliefNet bn) {
   int i;

   for(i = 0 ; i < BNGetNumNodes(bn) ; i++) {
      if(!gUseHeuristicBound) {
         _UpdateNodeScore(BNGetNodeByID(bn, i));
      } else {
         _UpdateNodeAveDataLL(BNGetNodeByID(bn, i));
      }
   }
}

static void _UpdateNetScore(BeliefNet bn) {
   BNUserData netData = BNGetUserData(bn);

   if(netData->changedOne) {
      if(!gUseHeuristicBound) {
         _UpdateNodeScore(netData->changedOne);
      } else {
         _UpdateNodeAveDataLL(netData->changedOne);
      }
   }
   if(netData->changedTwo) {
      if(!gUseHeuristicBound) {
         _UpdateNodeScore(netData->changedTwo);
      } else {
         _UpdateNodeAveDataLL(netData->changedTwo);
      }
   }
}

static double _GetStructuralDifferenceScoreNode(BeliefNetNode bnn) {
   int difference = 0;
   int i;
   BeliefNetNode priorNode;

   priorNode = BNGetNodeByID(gPriorNet, BNNodeGetID(bnn));
   for(i = 0 ; i < BNNodeGetNumParents(bnn) ; i++) {
      if(!BNNodeHasParentID(priorNode, BNNodeGetParentID(bnn, i))) {
         difference++;
      }
   }
   for(i = 0 ; i < BNNodeGetNumParents(priorNode) ; i++) {
      if(!BNNodeHasParentID(bnn, BNNodeGetParentID(priorNode, i))) {
         difference++;
      }
   }

   return difference * log(gKappa);
}

void _UpdateNodeBD(BeliefNetNode bnn) {
   int numCPTRows;
   BNNodeUserData data;
   int j, k;
   double numSamples;

   data = BNNodeGetUserData(bnn);

   /* if this is the current node or is changed from it */
   if(data->isChangedFromCurrent || (data->current == 0)) {
      data->avgDataLL = 0;
      numCPTRows = BNNodeGetNumCPTRows(bnn);
      numSamples = BNNodeGetNumSamples(bnn);

      for(j = 0 ; j < numCPTRows ; j++) {
         /* HACK for efficiency break BNN ADT */

         /* HERE HERE update this to use the probabilities from the
                 prior network */
         data->avgDataLL += 
            (StatLogGamma(BNNodeGetNumValues(bnn)) -
            StatLogGamma(BNNodeGetNumValues(bnn) + bnn->rowCounts[j]));

         for(k = 0 ; k < BNNodeGetNumValues(bnn) ; k++) {
            data->avgDataLL += 
               (StatLogGamma(1 + bnn->eventCounts[j][k]) -
                      StatLogGamma(1));
         }
      }
      /* now scale it by the likelihood of the node given structural prior */
      data->avgDataLL += _GetStructuralDifferenceScoreNode(bnn);
   }
}

static void _UpdateCurrentNetScoreBD(BeliefNet bn) {
   int i;

   for(i = 0 ; i < BNGetNumNodes(bn) ; i++) {
      _UpdateNodeBD(BNGetNodeByID(bn, i));
   }
}

static void _UpdateNetScoreBD(BeliefNet bn) {
   BNUserData netData = BNGetUserData(bn);

   if(netData->changedOne) {
      //if(!gUseHeuristicBound) {
      //   _UpdateNodeScore(netData->changedOne);
      //} else {
      _UpdateNodeBD(netData->changedOne);
      //}
   }
   if(netData->changedTwo) {
      //if(!gUseHeuristicBound) {
      //   _UpdateNodeScore(netData->changedTwo);
      //} else {
      _UpdateNodeBD(netData->changedTwo);
      //}
   }
}


static double _GetNodeScore(BeliefNetNode bnn) {
   BNNodeUserData data = BNNodeGetUserData(bnn);
   
   if(!gUseHeuristicBound) {
      if(data->current == 0 || data->isChangedFromCurrent) {
         return data->score;
      } else {
         return data->current->score;
      }
   } else {
      if(data->current == 0 || data->isChangedFromCurrent) {
         return data->avgDataLL;
      } else {
         return data->current->avgDataLL;
      }
   }
}

static double _GetNodeLowestScore(BeliefNetNode bnn) {
   BNNodeUserData data = BNNodeGetUserData(bnn);
   
   if(data->current == 0 || data->isChangedFromCurrent) {
      return data->lowerBound;
   } else {
      return data->current->lowerBound;
   }
}

static double _GetNodeHighestScore(BeliefNetNode bnn) {
   BNNodeUserData data = BNNodeGetUserData(bnn);
   
   if(data->current == 0 || data->isChangedFromCurrent) {
      return data->upperBound;
   } else {
      return data->current->upperBound;
   }
}


int _IsFirstNetHigherLowerBound(BeliefNet first, BeliefNet second);
int _IsFirstNetHigherLowerBound(BeliefNet first, BeliefNet second) {
   BNUserData firstData = BNGetUserData(first);
   BNUserData secondData = BNGetUserData(second);
   int i1, i2, i;
   double scoreOne, scoreTwo;
   
   scoreOne = scoreTwo = 0;
   i1 = i2 = -1;

   if(firstData->changedOne) {
      i = i1 = BNNodeGetID(firstData->changedOne);
      scoreOne += _GetNodeLowestScore(BNGetNodeByID(first, i));
      scoreTwo += _GetNodeLowestScore(BNGetNodeByID(second, i));
   }

   if(firstData->changedTwo) {
      i = i2 = BNNodeGetID(firstData->changedTwo);
      scoreOne += _GetNodeLowestScore(BNGetNodeByID(first, i));
      scoreTwo += _GetNodeLowestScore(BNGetNodeByID(second, i));
   }

   if(secondData->changedOne) {
      i = BNNodeGetID(secondData->changedOne);
      if(i != i1 && i != i2) {
         /* don't compare same nodes twice */
         scoreOne += _GetNodeLowestScore(BNGetNodeByID(first, i));
         scoreTwo += _GetNodeLowestScore(BNGetNodeByID(second, i));
      }
   }

   if(secondData->changedTwo) {
      i = BNNodeGetID(secondData->changedTwo);
      if(i != i1 && i != i2) {
         /* don't compare same nodes twice */
         scoreOne += _GetNodeLowestScore(BNGetNodeByID(first, i));
         scoreTwo += _GetNodeLowestScore(BNGetNodeByID(second, i));
      }
   }

   return scoreOne > scoreTwo;
}


double _GetCorrectBoundEpsilon(BeliefNet first, BeliefNet second) {
   BNUserData firstData = BNGetUserData(first);
   BNUserData secondData = BNGetUserData(second);
   int i1, i2, i;
   double scoreOne, scoreTwo, epsilon;
   
   epsilon = 0;
   scoreOne = scoreTwo = 0;
   i1 = i2 = -1;

   if(firstData->changedOne) {
      i = i1 = BNNodeGetID(firstData->changedOne);
      epsilon += _GetNodeScore(BNGetNodeByID(first, i)) -
                         _GetNodeLowestScore(BNGetNodeByID(first, i));
      epsilon += _GetNodeHighestScore(BNGetNodeByID(second, i)) - 
                         _GetNodeScore(BNGetNodeByID(second, i));
   }

   if(firstData->changedTwo) {
      i = i2 = BNNodeGetID(firstData->changedTwo);
      epsilon += _GetNodeScore(BNGetNodeByID(first, i)) -
                         _GetNodeLowestScore(BNGetNodeByID(first, i));
      epsilon += _GetNodeHighestScore(BNGetNodeByID(second, i)) - 
                         _GetNodeScore(BNGetNodeByID(second, i));
   }

   if(secondData->changedOne) {
      i = BNNodeGetID(secondData->changedOne);
      if(i != i1 && i != i2) {
         /* don't compare same nodes twice */
         epsilon += _GetNodeScore(BNGetNodeByID(first, i)) -
                         _GetNodeLowestScore(BNGetNodeByID(first, i));
         epsilon += _GetNodeHighestScore(BNGetNodeByID(second, i)) - 
                         _GetNodeScore(BNGetNodeByID(second, i));
      }
   }

   if(secondData->changedTwo) {
      i = BNNodeGetID(secondData->changedTwo);
      if(i != i1 && i != i2) {
         /* don't compare same nodes twice */
         epsilon += _GetNodeScore(BNGetNodeByID(first, i)) -
                         _GetNodeLowestScore(BNGetNodeByID(first, i));
         epsilon += _GetNodeHighestScore(BNGetNodeByID(second, i)) - 
                         _GetNodeScore(BNGetNodeByID(second, i));
      }
   }

   return epsilon;
}

float _ScoreBNOptimized(BeliefNet bn);

double _FirstLowerMinusSecondUpper(BeliefNet first, BeliefNet second);
double _FirstLowerMinusSecondUpper(BeliefNet first, BeliefNet second) {
   BNUserData firstData = BNGetUserData(first);
   BNUserData secondData = BNGetUserData(second);
   int i1, i2, i;
   double scoreOne, scoreTwo;
   
   scoreOne = scoreTwo = 0;
   i1 = i2 = -1;

   if(firstData->changedOne) {
      i = i1 = BNNodeGetID(firstData->changedOne);
      scoreOne += _GetNodeLowestScore(BNGetNodeByID(first, i));
      scoreTwo += _GetNodeHighestScore(BNGetNodeByID(second, i));
   }

   if(firstData->changedTwo) {
      i = i2 = BNNodeGetID(firstData->changedTwo);
      scoreOne += _GetNodeLowestScore(BNGetNodeByID(first, i));
      scoreTwo += _GetNodeHighestScore(BNGetNodeByID(second, i));
   }

   if(secondData->changedOne) {
      i = BNNodeGetID(secondData->changedOne);
      if(i != i1 && i != i2) {
         /* don't compare same nodes twice */
         scoreOne += _GetNodeLowestScore(BNGetNodeByID(first, i));
         scoreTwo += _GetNodeHighestScore(BNGetNodeByID(second, i));
      }
   }

   if(secondData->changedTwo) {
      i = BNNodeGetID(secondData->changedTwo);
      if(i != i1 && i != i2) {
         /* don't compare same nodes twice */
         scoreOne += _GetNodeLowestScore(BNGetNodeByID(first, i));
         scoreTwo += _GetNodeHighestScore(BNGetNodeByID(second, i));
      }
   }

   DebugMessage(1, 4, "     first %p %lf low %lf second %p %lf high %lf better %d\n", 
               first, _ScoreBNOptimized(first), scoreOne, 
               second, _ScoreBNOptimized(second), scoreTwo,
                               scoreOne > scoreTwo);
   return scoreOne - scoreTwo;
}

double _GetDeltaScore(BeliefNet first, BeliefNet second) {
   BNUserData firstData = BNGetUserData(first);
   BNUserData secondData = BNGetUserData(second);
   int i1, i2, i;
   double scoreOne, scoreTwo;
   
   scoreOne = scoreTwo = 0;
   i1 = i2 = -1;

   if(firstData->changedOne) {
      i = i1 = BNNodeGetID(firstData->changedOne);
      scoreOne += _GetNodeScore(BNGetNodeByID(first, i));
      scoreTwo += _GetNodeScore(BNGetNodeByID(second, i));
   }

   if(firstData->changedTwo) {
      i = i2 = BNNodeGetID(firstData->changedTwo);
      scoreOne += _GetNodeScore(BNGetNodeByID(first, i));
      scoreTwo += _GetNodeScore(BNGetNodeByID(second, i));
   }

   if(secondData->changedOne) {
      i = BNNodeGetID(secondData->changedOne);
      if(i != i1 && i != i2) {
         /* don't compare same nodes twice */
         scoreOne += _GetNodeScore(BNGetNodeByID(first, i));
         scoreTwo += _GetNodeScore(BNGetNodeByID(second, i));
      }
   }

   if(secondData->changedTwo) {
      i = BNNodeGetID(secondData->changedTwo);
      if(i != i1 && i != i2) {
         /* don't co