customersequentialminingmodel.java

一个数据挖掘软件ALPHAMINERR的整个过程的JAVA版源代码

      if ( !(miningData instanceof CustomSequence) )
        throw new MiningException("miningData not CustomSequence");

      if (recs == null) throw new MiningException("recommendations not builded");

      CustomSequence cs = (CustomSequence) miningData;

      // Find recommendations:
      System.out.println("Finding recommendation for "+cs+"("+cs.hashCode()+")");
      CustomRuleSetSeq crs = (CustomRuleSetSeq)recs.get(cs);

      return crs;
    }

    // -----------------------------------------------------------------------
    //  Methods of PMML handling
    // -----------------------------------------------------------------------
    /**
     * Write customer sequential model to PMML document.
     *
     * @param writer writer for writing PMML document
     * @exception MiningException cannot write PMML object
     */
    public void writePmml( Writer writer ) throws MiningException
    {
        PMML pmml = new PMML();
        pmml.setVersion( "2.0" );
        pmml.setHeader( (Header)PmmlUtils.getHeader() );
        MiningDataSpecification metaData = miningSettings.getDataSpecification();
        CategoricalAttribute customerId = (CategoricalAttribute) ((CustomerSequentialSettings)miningSettings).getCustomerId();
        customerId.setUnboundedCategories( ! isExportTransactIds() );
        if ( metaData.isTransformed() )
        {
            pmml.setDataDictionary( (DataDictionary)metaData.getPretransformedMetaData().createPmmlObject() );
            pmml.setTransformationDictionary( (com.prudsys.pdm.Adapters.PmmlVersion20.TransformationDictionary)metaData.getMiningTransformationActivity().createPmmlObject() );
        }
        else
        {
            pmml.setDataDictionary( (DataDictionary)metaData.createPmmlObject() );
        };

        SequenceModel smm = (SequenceModel)createPmmlObject();
        pmml.addSequenceModel(smm);

        // Add encoding and write to document:
        PmmlUtils.setEncoding();
        PmmlUtils.marshalPmml(writer, pmml);
    }

    /**
     * Write customer sequential model to PMML element SequenceModel.
     *
     * @return PMML element SequenceModel
     * @exception MiningException create PMML object
     * @see com.prudsys.pdm.Adapters.PmmlVersion20.SequenceModel
     */
    public Object createPmmlObject() throws MiningException
    {
        SequenceModel smm = new SequenceModel();
        CustomerSequentialSettings seqset = (CustomerSequentialSettings)miningSettings;
        CategoricalAttribute cattr = (CategoricalAttribute)seqset.getCustomerId();
        int transNum = getNumberOfTransactions();
        smm.setNumberOfTransactions(Integer.toString(transNum));
        Vector seqRules = getSequentialRules();
        smm.setModelName("Sequential basket model");
        smm.setFunctionName("sequences");
        smm.setAlgorithmName(algorithm);
        smm.setNumberOfSequences(Integer.toString(seqRules.size()));
//        smm.setMaxNumberOfItemsPerTransaction("0");
//        smm.setAvgNumberOfItemsPerTransaction("0");
        smm.setMinimumSupport(Double.toString(seqset.getMinimumSupport()));
        smm.setMinimumConfidence(Double.toString(seqset.getMinimumConfidence()));
        CategoricalAttribute iattr = (CategoricalAttribute)seqset.getItemId();
        smm.setNumberOfItems(Integer.toString(iattr.getCategoriesNumber()));
        int numberOfRules = 0;
        Vector sequenceRules = getSequenceRules();
        if (sequenceRules != null) numberOfRules = sequenceRules.size();
        smm.setNumberOfRules( Integer.toString(numberOfRules) );
        smm.setNumberOfSets("0");
        if (getExportTransactItemNames() == EXPORT_PMML_NAME_TYPE_XELOPES) {
          smm.setItemIdName( iattr.getName() );
          smm.setTransactIdName( cattr.getName() );
          smm.setPositionIdName( seqset.getTransactionPosition().getName() );
        };
        smm.setMiningSchema( (MiningSchema)inputSpec.createPmmlObject() );

        int itemsNum = iattr.getCategoriesNumber();
        for(int i=0;i<itemsNum;i++)
        {
            Category category = (Category)iattr.getCategory((double)i);
            Item item = new Item();
            item.setId("it"+i);
            item.setValue(category.getDisplayValue());
            smm.addItem(item);
        }
        int seqNum = seqRules.size();
        java.util.Hashtable itemsets = new java.util.Hashtable();
        int itemsetsCounter = 0;
        Hashtable is2id = new Hashtable();
        for(int i=0;i<seqNum;i++)
        {
       CustomSequence cs = (CustomSequence)seqRules.get(i);
       Sequence seq = new Sequence();
       seq.setNumberOfSets(Integer.toString(cs.getSize()));
       String id = "seq"+i;
       seq.setId(id);
       is2id.put(cs, id);
//       SequenceDescription desc = new SequenceDescription();
//       desc.setNumberOfSets(Integer.toString(cs.getSize()));
//       desc.setOccurrence("__"); // ???
       seq.setSupport(Double.toString((double)cs.getSupportCount()/(double)transNum));
//       seq.setSequenceDescription(desc);
       int csSize = cs.getSize();
       for(int j=0;j<csSize;j++)
       {
          com.prudsys.pdm.Models.AssociationRules.ItemSet is = cs.getItemSet(j);
          String iid = (String)itemsets.get(is);
          if(iid==null)
          {
            iid = "is"+itemsetsCounter;
            itemsetsCounter++;
            itemsets.put(is,iid);
            com.prudsys.pdm.Adapters.PmmlVersion20.Itemset pis = new com.prudsys.pdm.Adapters.PmmlVersion20.Itemset();;
            pis.setId(iid);
            pis.setNumberOfItems(Integer.toString(is.getSize()));
            for(int k=0;k<is.getSize();k++)
            {
              ItemRef ir = new ItemRef();
              ir.setItemRef("it"+is.getItemAt(k));
              pis.addItemRef(ir);
            }
            smm.addItemset(pis);
          }
          SetReference ref = new SetReference();
          ref.setSetId(iid);
          if(j==0) seq.setSetReference(ref);
          else seq.addSetReference1(ref);
          if(j!=csSize-1)
          {
            Delimiter delim = new Delimiter();
            delim.setDelimiter("sameTimeWindow");
            delim.setGap("false");
            seq.addDelimiter(delim);
          }
        }
        smm.addSequence(seq);
      }
      smm.setNumberOfSets( Integer.toString(itemsetsCounter) );

      SequenceRule[] seqRule = new SequenceRule[numberOfRules];
      for(int i = 0; i < numberOfRules; i++)
      {
        CustomRuleSetSeq crs = (CustomRuleSetSeq) sequenceRules.elementAt(i);
        double support    = crs.getSupport();
        double confidence = crs.getConfidence();
        int itemSize = crs.getSize();
        CustomSequence premise = crs.getPremise();
        CustomSequence conclusion = crs.getConclusion();
        int nprem    = premise.getSize();
        int nconcl = conclusion.getSize();

        seqRule[i] = new SequenceRule();
        seqRule[i].setId("rule"+i);
        seqRule[i].setSupport( "" + support );
        seqRule[i].setConfidence( "" + confidence );
        AntecedentSequence as = new AntecedentSequence();
        SequenceReference ref = new SequenceReference();
        ref.setSeqId( (String) is2id.get(premise) );
        as.setSequenceReference( ref );
        seqRule[i].setAntecedentSequence(as);

        Delimiter delim = new Delimiter();
        delim.setDelimiter("sameTimeWindow");
        delim.setGap("unknown");
        seqRule[i].setDelimiter(delim);

        ConsequentSequence cs = new ConsequentSequence();
        ref = new SequenceReference();
        ref.setSeqId( (String) is2id.get(conclusion) );
        cs.setSequenceReference( ref );
        seqRule[i].setConsequentSequence(cs);
      }
      smm.setSequenceRule( seqRule );

      return smm;
    }

    /**
     * Read customer sequential model from PMML document. Not supported.
     *
     * @param reader reader for PMML document
     * @exception MiningException always thrown
     */
    public void readPmml( Reader reader ) throws MiningException
    {
//      com.borland.xml.toolkit.XmlUtil.setEncoding( "UTF-8" );
      PMML pmml = PMML.unmarshal( reader );
      if(pmml.getSequenceModelCount()==0)
        throw new MiningException("no customer sequential model found");

      // Read data dictionary:
      DataDictionary dictionary = pmml.getDataDictionary();
      MiningDataSpecification newMetaData = new MiningDataSpecification();
      newMetaData.parsePmmlObject( dictionary );

      // Read transformation dictionary:
      TransformationDictionary transDict = pmml.getTransformationDictionary();
      if (transDict != null) {
        MiningTransformationActivity mta = new MiningTransformationActivity();
        mta.parsePmmlObject(transDict);
        MiningDataSpecification tmds = mta.transform(newMetaData);
        tmds.setPretransformedMetaData(newMetaData);
        newMetaData = tmds;
        newMetaData.setMiningTransformationActivity( mta );
        newMetaData.setTransformed(true);
      };

      // Init settings:
      CustomerSequentialSettings css = new CustomerSequentialSettings();
      css.setDataSpecification(newMetaData);
      miningSettings = css;

      // Read customer sequential model:
      SequenceModel model = pmml.getSequenceModel(0);
      parsePmmlObject(model);
    }

    /**
     * Read customer sequential model from PMML element SequenceModel.
     *
     * @param pmmlObject PMML element SuquenceModel
     * @exception MiningException could not parse model
     * @see com.prudsys.pdm.Adapters.PmmlVersion20.SequenceModel
     */
    public void parsePmmlObject( Object pmmlObject ) throws MiningException
    {
      Vector sequentialRules = new Vector();
      SequenceModel model = (SequenceModel)pmmlObject;
      int transNum = Integer.parseInt(model.getNumberOfTransactions());

      // Get settings:
      CustomerSequentialSettings custset = (CustomerSequentialSettings)miningSettings;
      double supp = Double.parseDouble(model.getMinimumSupport());
      custset.setMinimumSupport(supp);
      double conf = Double.parseDouble(model.getMinimumConfidence());
      custset.setMinimumConfidence(conf);
      String itemIdName = "itemId";
      String customerIdName = "customerId";
      String transactionPositionName = "transactionPosition";
      int exportTransactItemNames = SequentialMiningModel.EXPORT_PMML_NAME_TYPE_XELOPES;
      if (model.getItemIdName() != null) {
        itemIdName = model.getItemIdName();
        exportTransactItemNames = EXPORT_PMML_NAME_TYPE_XELOPES;
      };
      if (model.getTransactIdName() != null) {
        customerIdName = model.getTransactIdName();
        exportTransactItemNames = EXPORT_PMML_NAME_TYPE_XELOPES;
      };
      if (model.getPositionIdName() != null) {
        transactionPositionName = model.getPositionIdName();
        exportTransactItemNames = EXPORT_PMML_NAME_TYPE_XELOPES;
      };
      setExportTransactItemNames(exportTransactItemNames);
      MiningDataSpecification metaData = custset.getDataSpecification();
      CategoricalAttribute customerId, itemId;
      NumericAttribute transactionPosition;
      try
      {
          customerId = (CategoricalAttribute)metaData.getMiningAttribute(customerIdName);
          itemId     = (CategoricalAttribute)metaData.getMiningAttribute(itemIdName);
          transactionPosition  = (NumericAttribute)metaData.getMiningAttribute(transactionPositionName);
      }
      catch (ClassCastException ex)
      {
          throw new MiningException("customerId and itemId attributes must be categorical, transactionPosition numeric");
      }
      custset.setItemId(itemId);
      custset.setCustomerId(customerId);
      custset.setTransactionPosition(transactionPosition);

      // Get AIS:
      MiningSchema schema = model.getMiningSchema();
      if( schema != null )
      {
          inputSpec = new ApplicationInputSpecification();
          inputSpec.parsePmmlObject( schema );
          inputSpec.initApplicationInputSpecification( custset );
      }
      else
      {
          inputSpec = new ApplicationInputSpecification( custset.getDataSpecification() );
          inputSpec.initApplicationInputSpecification( custset );
      }

      // Get sequences:
      Item[] its      = model.getItem();
      Hashtable items = new Hashtable();
      for (int i = 0; i < its.length; i++)
      {
         Category cat = new Category( its[i].getValue() );
         double dbl = itemId.getKey(cat);
         items.put( its[i].getId(), new Integer((int)dbl) );
      };

      Itemset[] itsets   = model.getItemset();
      Hashtable itemsets = new Hashtable();
      for (int i = 0; i < itsets.length; i++)
      {
        ItemSet is = new ItemSet();
        int setNum = Integer.parseInt( itsets[i].getNumberOfItems() );
        for (int j = 0; j < setNum; j++)
        {
          String itId = itsets[i].getItemRef(j).getItemRef();
          int val = ((Integer)items.get(itId) ).intValue();
          is.addItem(val);
        };
        itemsets.put( itsets[i].getId(), is );
      };

      Sequence[] seqs       = model.getSequence();
      Hashtable itemsetsMap = new Hashtable();
      for (int i = 0; i < seqs.length; i++)
      {
        CustomSequence cs = new CustomSequence();
        supp = Double.parseDouble( seqs[i].getSupport() );
        cs.setSupportCount( (int)(supp*transNum+.999999) );
        int setNum = Integer.parseInt( seqs[i].getNumberOfSets() );
        for (int j = 0; j < setNum; j++)
        {
          String sr = seqs[i].getSetReference1(j).getSetId();
          ItemSet is = (ItemSet) itemsets.get(sr);
          cs.addItemSet(is);
        };
        itemsetsMap.put( seqs[i].getId(), cs );
        sequentialRules.add(cs);
      };
      setSequentialRules(sequentialRules);

      // Get rules:
      Vector sequenceRules = new Vector();
      SequenceRule[] rules = model.getSequenceRule();
      for (int i = 0; i < rules.length; i++)
      {
        CustomSequence antecedent = (CustomSequence)itemsetsMap.get(rules[i].getAntecedentSequence().getSequenceReference().getSeqId());
        CustomSequence consequent = (CustomSequence)itemsetsMap.get(rules[i].getConsequentSequence().getSequenceReference().getSeqId());
        if (antecedent == null || consequent == null) throw new MiningException("bad itemset reference in sequence rule");
        double supp2 = Double.parseDouble(rules[i].getSupport());
        double conf2 = Double.parseDouble(rules[i].getConfidence());
        CustomRuleSetSeq crs = new CustomRuleSetSeq(antecedent, consequent, supp2, conf2);
        sequenceRules.add(crs);
      };
      setSequenceRules(sequenceRules);
    }

    // -----------------------------------------------------------------------
    //  Other export methods