aode.java

代码是一个分类器的实现,其中使用了部分weka的源代码。可以将项目导入eclipse运行

    // is more efficient in loop(s).
    int [] attIndex = new int[m_NumAttributes];
    for(int att = 0; att < m_NumAttributes; att++) {
       if(instance.isMissing(att) || att == m_ClassIndex)
          attIndex[att] = -1;   // can't use class or missing values in calculations
       else
	  attIndex[att] = m_StartAttIndex[att] + (int)instance.value(att);
    }

    // calculate probabilities for each possible class value
    for(int classVal = 0; classVal < m_NumClasses; classVal++) {
 
       probs[classVal] = 0;
       double spodeP = 0;  // P(X,y) for current parent and class
       parentCount = 0;
 
       countsForClass = m_CondiCounts[classVal];

       // each attribute has a turn of being the parent
       for(int parent = 0; parent < m_NumAttributes; parent++) {
          if(attIndex[parent] == -1)
             continue;  // skip class attribute or missing value

          // determine correct index for the parent in m_CondiCounts matrix
          pIndex = attIndex[parent];

          // check that the att value has a frequency of m_Limit or greater
	  if(m_Frequencies[pIndex] < m_Limit) 
             continue;

          countsForClassParent = countsForClass[pIndex];

          // block the parent from being its own child
          attIndex[parent] = -1;

          parentCount++;

          // joint frequency of class and parent
          double classparentfreq = countsForClassParent[pIndex];

          // find the number of missing values for parent's attribute
          double missing4ParentAtt = 
              m_Frequencies[m_StartAttIndex[parent] + m_NumAttValues[parent]];

          // calculate the prior probability -- P(parent & classVal)
          if (!m_MEstimates) {
             spodeP = (classparentfreq + 1.0)
                / ((m_SumInstances - missing4ParentAtt) + m_NumClasses
	           * m_NumAttValues[parent]);
          } else {
             spodeP = (classparentfreq + ((double)m_Weight
                        / (double)(m_NumClasses * m_NumAttValues[parent])))
                / ((m_SumInstances - missing4ParentAtt) + m_Weight);
          }

          // take into account the value of each attribute
          for(int att = 0; att < m_NumAttributes; att++) {
             if(attIndex[att] == -1)
                continue;
 
             double missingForParentandChildAtt = 
              countsForClassParent[m_StartAttIndex[att] + m_NumAttValues[att]];

             if(!m_MEstimates) {
                spodeP *= (countsForClassParent[attIndex[att]] + 1.0)
                    / ((classparentfreq - missingForParentandChildAtt)
                       + m_NumAttValues[att]);
             } else {
                spodeP *= (countsForClassParent[attIndex[att]]
                           + ((double)m_Weight / (double)m_NumAttValues[att]))
                    / ((classparentfreq - missingForParentandChildAtt)
                       + m_Weight);
             }
          }

          // add this probability to the overall probability
          probs[classVal] += spodeP;
 
          // unblock the parent
          attIndex[parent] = pIndex;
       }
 
       // check that at least one att was a parent
       if(parentCount < 1) {

          // do plain naive bayes conditional prob
	  probs[classVal] = NBconditionalProb(instance, classVal);

       } else {
 
          // divide by number of parent atts to get the mean
          probs[classVal] /= (double)(parentCount);
       }
    }
 
    Utils.normalize(probs);
    return probs;
  }


  /**
   * Calculates the probability of the specified class for the given test
   * instance, using naive Bayes.
   *
   * @param instance the instance to be classified
   * @param classVal the class for which to calculate the probability
   * @return predicted class probability
   */
  public double NBconditionalProb(Instance instance, int classVal) {
    
    double prob;
    double [][] pointer;

    // calculate the prior probability
    if(!m_MEstimates) {
       prob = (m_ClassCounts[classVal] + 1.0) / (m_SumInstances + m_NumClasses);
    } else {
       prob = (m_ClassCounts[classVal]
               + ((double)m_Weight / (double)m_NumClasses))
             / (m_SumInstances + m_Weight);
    }
    pointer = m_CondiCounts[classVal];
    
    // consider effect of each att value
    for(int att = 0; att < m_NumAttributes; att++) {
       if(att == m_ClassIndex || instance.isMissing(att))
          continue;

       // determine correct index for att in m_CondiCounts
       int aIndex = m_StartAttIndex[att] + (int)instance.value(att);

       if(!m_MEstimates) {
          prob *= (double)(pointer[aIndex][aIndex] + 1.0)
              / ((double)m_SumForCounts[classVal][att] + m_NumAttValues[att]);
       } else {
          prob *= (double)(pointer[aIndex][aIndex] 
                    + ((double)m_Weight / (double)m_NumAttValues[att]))
                 / (double)(m_SumForCounts[classVal][att] + m_Weight);
       }
    }
    return prob;
  }


  /**
   * Returns an enumeration describing the available options
   *
   * @return an enumeration of all the available options
   */
  public Enumeration listOptions() {
        
    Vector newVector = new Vector(4);
        
    newVector.addElement(
       new Option("\tOutput debugging information\n",
                  "D", 0,"-D"));
    newVector.addElement(
       new Option("\tImpose a frequency limit for superParents\n"
                  + "\t(default is 1)", "F", 1,"-F <int>"));
    newVector.addElement(
       new Option("\tUse m-estimate instead of laplace correction\n",
                  "M", 0,"-M"));
    newVector.addElement(
       new Option("\tSpecify a weight to use with m-estimate\n"
                  + "\t(default is 1)", "W", 1,"-W <int>"));
    return newVector.elements();
  }

    
  /**
   * Parses a given list of options. <p/>
   * 
   <!-- options-start -->
   * Valid options are: <p/>
   * 
   * <pre> -D
   *  Output debugging information
   * </pre>
   * 
   * <pre> -F &lt;int&gt;
   *  Impose a frequency limit for superParents
   *  (default is 1)</pre>
   * 
   * <pre> -M
   *  Use m-estimate instead of laplace correction
   * </pre>
   * 
   * <pre> -W &lt;int&gt;
   *  Specify a weight to use with m-estimate
   *  (default is 1)</pre>
   * 
   <!-- options-end -->
   *
   * @param options the list of options as an array of strings
   * @throws Exception if an option is not supported
   */
  public void setOptions(String[] options) throws Exception {

    m_Debug = Utils.getFlag('D', options);

    String Freq = Utils.getOption('F', options);
    if (Freq.length() != 0) 
       m_Limit = Integer.parseInt(Freq);
    else
       m_Limit = 1;
 
    m_MEstimates = Utils.getFlag('M', options);
    String weight = Utils.getOption('W', options);
    if (weight.length() != 0) {
       if (!m_MEstimates)
          throw new Exception("Can't use Laplace AND m-estimate weight. Choose one.");
       m_Weight = Integer.parseInt(weight);
    } 
    else {
       if (m_MEstimates)
          m_Weight = 1;
    }

    Utils.checkForRemainingOptions(options);
  }
    
  /**
   * Gets the current settings of the classifier.
   *
   * @return an array of strings suitable for passing to setOptions
   */
  public String [] getOptions() {
    Vector result  = new Vector();

    if (m_Debug)
       result.add("-D");
        
    result.add("-F");
    result.add("" + m_Limit);

    if (m_MEstimates) {
       result.add("-M");
       result.add("-W");
       result.add("" + m_Weight);
    }
    
    return (String[]) result.toArray(new String[result.size()]);
  }
    
  /**
   * Returns the tip text for this property
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String setWeightTipText() {
    return "Set the weight for m-estimate.";
  }

  /**
   * Sets the weight for m-estimate
   *
   * @param w the weight
   */
  public void setWeight(int w) {
    if (!getUseMEstimates()) {
      System.out.println(
          "Weight is only used in conjunction with m-estimate - ignored!");
    }
    else {
      if (w > 0)
        m_Weight = w;
      else
        System.out.println("Weight must be greater than 0!");
    }
  }

  /**
   * Gets the weight used in m-estimate
   *
   * @return the frequency limit
   */
  public int getWeight() {
    return m_Weight;
  }

  /**
   * Returns the tip text for this property
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String useMEstimatesTipText() {
    return "Use m-estimate instead of laplace correction.";
  }

  /**
   * Gets if m-estimaces is being used.
   *
   * @return Value of m_MEstimates.
   */
  public boolean getUseMEstimates() {
    return m_MEstimates;
  }

  /**
   * Sets if m-estimates is to be used.
   *
   * @param value     Value to assign to m_MEstimates.
   */
  public void setUseMEstimates(boolean value) {
    m_MEstimates = value;
  }

  /**
   * Returns the tip text for this property
   * @return tip text for this property suitable for
   * displaying in the explorer/experimenter gui
   */
  public String frequencyLimitTipText() {
    return "Attributes with a frequency in the train set below "
           + "this value aren't used as parents.";
  }

  /**
   * Sets the frequency limit
   *
   * @param f the frequency limit
   */
  public void setFrequencyLimit(int f) {
    m_Limit = f;
  }

  /**
   * Gets the frequency limit.
   *
   * @return the frequency limit
   */
  public int getFrequencyLimit() {
    return m_Limit;
  }

  /**
   * Returns a description of the classifier.
   *
   * @return a description of the classifier as a string.
   */
  public String toString() {
 
    StringBuffer text = new StringBuffer();
        
    text.append("The AODE Classifier");
    if (m_Instances == null) {
       text.append(": No model built yet.");
    } else {
       try {
          for (int i = 0; i < m_NumClasses; i++) {
             // print to string, the prior probabilities of class values
             text.append("\nClass " + m_Instances.classAttribute().value(i) +
                       ": Prior probability = " + Utils.
                          doubleToString(((m_ClassCounts[i] + 1)
                       /(m_SumInstances + m_NumClasses)), 4, 2)+"\n\n");
          }
                
          text.append("Dataset: " + m_Instances.relationName() + "\n"
                      + "Instances: " + m_NumInstances + "\n"
                      + "Attributes: " + m_NumAttributes + "\n"
		      + "Frequency limit for superParents: " + m_Limit + "\n");
          text.append("Correction: ");
          if (!m_MEstimates)
             text.append("laplace\n");
          else
             text.append("m-estimate (m=" + m_Weight + ")\n");
                
       } catch (Exception ex) {
          text.append(ex.getMessage());
       }
    }
        
    return text.toString();
  }
    
    
  /**
   * Main method for testing this class.
   *
   * @param argv the options
   */
  public static void main(String [] argv) {
    runClassifier(new AODE(), argv);
  }
}