id3.java

一个数据挖掘系统的源码

        pmmlPredicate(depth);
        treeModelElement.addContent(createPredicates());

       // Create the XML document
        DocType dtd = new DocType("pmml_2_0.dtd");
        Document doc = new Document (versionElement,dtd);
        XMLOutputter output = new XMLOutputter ();

        output.setIndent("  ");
        output.setNewlines(true);
       // Output to System.out
//        output.output(doc, System.out);
//        pmmlDocumentString = output.outputString(doc);

//        PmmlStringBuffer = (StringBuffer) bout;
       // Output to file
//        output.output(doc, bout);


     pmmlDocument = doc;
     }
      catch (Exception e){
        log.error ("PMML Document Exception: " + e);
        log.error(e.getStackTrace().toString());
      }
//        System.out.println("Document einai to e3is amesws parakatw: " + pmmlString);
   }

   /**
    * Creates the pmml Element
    * @exception e if the initial node creation for the PMML document goes wrong
    */
   private Element pmmlIntro () throws Exception {

      Element pmmlIntro = new Element ("PMML");
      return pmmlIntro;
   }

  /**
   * Create the Header Element
   */
   private Element header () throws Exception {

      Element header = new Element ("Header");
      String headerString = " The tree model of ";
      headerString  = headerString.concat(m_train.relationName());
      header.setAttribute("copyright", "issel.ee.auth.gr");
      header.setAttribute("description", headerString);
      Element applicationNameElement = new Element ("Application");
      applicationNameElement.setAttribute("name", "Agent Academy Data Miner");
      applicationNameElement.setAttribute("version", "0.3");
      header.addContent(applicationNameElement);

   return header;
   }

   /**
    *  Create the DataDictionary for the pre - specified XML file
    *  @exception e if the DataDictionary is not correctly created
    */
    private Element dataDictionary () throws Exception {

      Element dataDictionary = new Element ("DataDictionary");
      Element dataFieldElement;
      Element attributeValueElement;
      FastVector headerVector = m_train.getVector();
      String attributeName;
      String attributeType;
      String attributeValueString;
      int numberOfFields = m_train.numAttributes();
      String numberOfFieldsString = String.valueOf(numberOfFields);
      dataDictionary.setAttribute("numberOfFields", numberOfFieldsString );
      for (int i=0; i < headerVector.size();i++){
        dataFieldElement = new Element ("DataField");
        org.agentacademy.modules.dataminer.core.Attribute a = null;
        a = (org.agentacademy.modules.dataminer.core.Attribute) headerVector.elementAt(i);
        attributeName = a.name();
        dataFieldElement.setAttribute("name", attributeName);
        if (a.isNominal()){
          attributeType = "categorical";
          dataFieldElement.setAttribute("optype",attributeType);
          //
          Enumeration enumerateValues = a.enumerateValues();
          while (enumerateValues.hasMoreElements()){
              attributeValueString = (String)enumerateValues.nextElement();
              attributeValueElement = new Element ("Value");
              attributeValueElement.setAttribute("value", attributeValueString);
              dataFieldElement.addContent(attributeValueElement);
          }
        }
        else if (a.isNumeric()){
          attributeType = "continuous";
          dataFieldElement.setAttribute("optype",attributeType);
        }
        else if (a.isRegular()){
          attributeType = "ordinal";
          dataFieldElement.setAttribute("optype",attributeType);
        }
        else {
          attributeType = "string";
          dataFieldElement.setAttribute("optype",attributeType);
        }
      dataDictionary.addContent(dataFieldElement);
      }
    return dataDictionary;
    }

   /**
    * Creates the TreeModel Element
    */
    private Element treeModel () throws Exception{

        Element treeModel = new Element ("TreeModel");
        String modelNameString = m_train.relationName();
        treeModel.setAttribute("modelName", modelNameString);

    return treeModel;
    }

   /**
    * Creates the Mining Schema Element
    */

   private Element miningSchema () throws Exception {

       Element miningSchema = new Element ("MiningSchema");
       String attributeName;
       FastVector miningSchemaVector = m_train.getVector();
       for (int i=0; i < miningSchemaVector.size();i++){
          Element miningFieldElement = new Element ("MiningField");
          org.agentacademy.modules.dataminer.core.Attribute a = (org.agentacademy.modules.dataminer.core.Attribute) miningSchemaVector.elementAt(i);
          attributeName = a.name();
          miningFieldElement.setAttribute("name", attributeName);
          if (m_train.classIndex() == i){
            miningFieldElement.setAttribute("usageType", "predicted");
          }
          else{
            miningFieldElement.setAttribute("usageType", "active");
          }
          miningSchema.addContent(miningFieldElement);
      }
   return miningSchema;
   }

   /**
    *   Create Predicates using a Vector that finds that last leaf and returns
    *
    */
   private Element createPredicates () throws Exception {
      Element predicateElement = newNode();
      Element elementFather;
      int ruleDepthIndex;
      int nextRuleDepthIndex;
      String field;
      String operator;
      String value;
      String resultString;
      String field1, operator1, value1, resultString1;
      Vector propatores = new Vector();
      for (int papa = 0; papa < ruleVector.size(); papa++){
          log.debug ("[" + papa +"]= "+ (String) ruleVector.elementAt(papa));
      }
      int firstDepth = Integer.parseInt((String) ruleVector.elementAt(3));
      int secondDepth = Integer.parseInt((String) ruleVector.elementAt(8));
      int routing;
      field1 = (String)ruleVector.elementAt(0);
      operator1 = (String)ruleVector.elementAt(1);
      value1 = (String)ruleVector.elementAt(2);
      resultString1 = (String)ruleVector.elementAt(4);
      // If the first Element has a Leaf then create the SimplePredicate, the Leaf
      // and input all these to the elementFather

      if (firstDepth == secondDepth){

        Element prwtoElement = pmmlSimplePredicate (field1,operator1, value1);
        predicateElement.addContent(prwtoElement);
        predicateElement.addContent(newLeaf(resultString1));
        elementFather = predicateElement;
        routing = 5;
//        System.out.println("Ama pearsw apo edw malakia mou");
      }
      else {

        Element prwtoElement = pmmlSimplePredicate (field1,operator1, value1);
        predicateElement.addContent(prwtoElement);
        elementFather = predicateElement;
        routing = 5;
//        System.out.println("Kanw ena mesa");
      }
      for (int counter = routing; counter < ruleVector.size(); counter = counter + 5){
            ruleDepthIndex = counter + 3;
            nextRuleDepthIndex = counter + 8;
            field = (String)ruleVector.elementAt(counter);
//            System.out.print(field);
            operator = (String)ruleVector.elementAt(counter + 1);
//            System.out.print(operator);
            value = (String)ruleVector.elementAt(counter + 2);
//            System.out.print(value);
            resultString = (String)ruleVector.elementAt(counter + 4);
//            System.out.print("\n");
            int nextRuleDepth;
            int ruleDepth = Integer.parseInt((String) ruleVector.elementAt(ruleDepthIndex)) ;
            if (nextRuleDepthIndex < ruleVector.size()){
               nextRuleDepth = Integer.parseInt((String) ruleVector.elementAt(nextRuleDepthIndex)) ;
            }
            else{
               nextRuleDepth = 0;
            }
            int substract = ruleDepth - nextRuleDepth ;
            if (substract == 0){
                Element babisElement = newNode();
                Element temPredicate = pmmlSimplePredicate (field, operator, value);
                Element tempLeaf = newLeaf(resultString);
                babisElement.addContent(temPredicate);
                babisElement.addContent(tempLeaf);
                elementFather.addContent(babisElement);
            }
            else if (substract == -1){
                Element babisElement = newNode();
                propatores.add(elementFather);
                Element temPredicate = pmmlSimplePredicate (field, operator, value);
                babisElement.addContent(temPredicate);
                elementFather = babisElement;
            }
            else {
                Element babisElement = newNode();
                Element temPredicate = pmmlSimplePredicate (field, operator, value);
                Element tempLeaf = newLeaf(resultString);
                babisElement.addContent(temPredicate);
                babisElement.addContent(tempLeaf);
                elementFather.addContent(babisElement);
//              Ean Oi propatores einai kenoi tote min tre3eis to loop
                if (propatores.size() != 0){
                  Element newChild = elementFather;
//                  System.out.println("Diafora = " + substract);
//                  System.out.println("Vector size = " + propatores.size());
                  int afair;
                  if (substract < propatores.size()){
                    afair = substract;
                  }
                  else {
                    afair= propatores.size();

                  }
                  for (int i = 0 ; i<afair; i++){
                      elementFather = (Element) propatores.lastElement();
                      elementFather.addContent(newChild);
                      propatores.removeElementAt(propatores.indexOf(propatores.lastElement()));
                      newChild = elementFather;
                  }
                }
            } // and of else
      } //end of for
   predicateElement = elementFather;
   return predicateElement;
   }

/**
 * Create new Node Element
 */
 private Element newNode () {
    Element newNodeElement = new Element ("Node");
    newNodeElement.setAttribute("score", "play");
    return newNodeElement;
 }

 /**
  * Create new leaf
  */
 private Element newLeaf (String resultSubstring) throws Exception {

            String result = resultSubstring;
            Element leafElement = new Element ("Node");
            Element trueElement = new Element ("TRUE");
            leafElement.setAttribute("score",result);
            leafElement.addContent(trueElement);
            return leafElement;
   }

  /**
   * New class for creating a PMML output
   * @exception Exception if something goes wrong
   *
   */
  private void pmmlPredicate(int level) throws Exception {

    int j = level;
    String pmmlTreeSimplePredicateString = "";
    String pmmlTreeCompoundPredicateString = "";
    String pmmlTreeField = "";
    String pmmlTreeOperator = "";
    String pmmlTreeValue = "";
    String resultOutcome = " No value";

    if (m_Attribute == null) {
      if (Instance.isMissingValue(m_ClassValue)) {
         resultOutcome = "No value";
      }
      else {
//         System.out.println("Twra ektupwnw fullo");
         resultOutcome = m_ClassAttribute.value((int) m_ClassValue);
         System.out.println("Fullo = " +resultOutcome);
         ruleVector.removeElementAt(ruleVector.size()-1);
         ruleVector.addElement(resultOutcome);
/*
         for (int papa = 0; papa < ruleVector.size(); papa++){
                    System.out.println ("[" + papa +"]= "+ (String) ruleVector.elementAt(papa));
         }
*/
     }
    }
    else{
      for (int iota =0; iota <m_Attribute.numValues(); iota ++) {
//          System.out.println("Twra paw pio mesa");
          pmmlTreeField = m_Attribute.name();
          pmmlTreeOperator = "equal";
          pmmlTreeValue = m_Attribute.value(iota);
          System.out.println("Predicate Rule =" + pmmlTreeField + pmmlTreeOperator + pmmlTreeValue);

          ruleVector.addElement(pmmlTreeField);
          ruleVector.addElement(pmmlTreeOperator);
          ruleVector.addElement(pmmlTreeValue);
          ruleVector.addElement(String.valueOf(level));
          ruleVector.addElement(resultOutcome);
/*
          for (int papa = 0; papa < ruleVector.size(); papa++){
              System.out.println ("[" + papa +"]= "+ (String) ruleVector.elementAt(papa));
          }
*/
          m_Successors[iota].pmmlPredicate(level+1);
        // In order to construct the treeModel document we have to check whether it is the first child
        // or not and call the appropriate method
        //If the node is not a Leaf

      }

    }
  }

 /**
   * Creates a Simple Predicate for the first rule
   */

  private Element pmmlSimplePredicateFirst (String Field, String Operator, String Value) {

      String pmmlTreeField = Field;
      String pmmlTreeOperator = Operator;
      String pmmlTreeValue = Value;

      Element simplePredicateElementFirst = new Element ("Node");

//      simplePredicateElementFirst.setAttribute("field", pmmlTreeField);
//      simplePredicateElementFirst.setAttribute("operator", pmmlTreeOperator);
//      simplePredicateElementFirst.setAttribute("value", pmmlTreeValue);

      return simplePredicateElementFirst;
      }
  /**
   * Creates a Simple Predicate for the next rules
   */

  private Element pmmlSimplePredicate (String Field, String Operator, String Value) {

      String pmmlTreeField = Field;
      String pmmlTreeOperator = Operator;
      String pmmlTreeValue = Value;

      Element simplePredicateElement = new Element ("SimplePredicate");
      simplePredicateElement.setAttribute("field", pmmlTreeField);
      simplePredicateElement.setAttribute("operator", pmmlTreeOperator);
      simplePredicateElement.setAttribute("value", pmmlTreeValue);

      return simplePredicateElement;
      }

}