sequentialminingmodel.java

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

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

      // Form itemset:
      ItemSetSeq is = null;
      if (miningData instanceof ItemSetSeq)
        is = (ItemSetSeq) miningData;
      else {
        SequentialSettings arset = (SequentialSettings)miningSettings;
        CategoricalAttribute itemId = (CategoricalAttribute)arset.getItemId();

        MiningVector mv = (MiningVector) miningData;
        MiningDataSpecification metaData = mv.getMetaData();

        for (int i = 0; i < metaData.getAttributesNumber(); i++) {
          CategoricalAttribute catAtt = (CategoricalAttribute) metaData.getMiningAttribute(i);
          Category cat = catAtt.getCategory( mv.getValue(i) );
          is.addItem((int)itemId.getKey(cat));
        };
      };

      // Find recommendations:
      System.out.println("Finding recommendation for "+is+"("+is.hashCode()+")");
      RuleSetSeq rs = (RuleSetSeq)recs.get(is);

      return rs;
    }

    // -----------------------------------------------------------------------
    //  Methods of PMML handling
    // -----------------------------------------------------------------------
    /**
     * Creates PMML document of sequential model.
     * PMMLs SequenceModel is used.
     *
     * @param writer writer for PMML model
     * @exception MiningException cannot write PMML document
     * @see com.prudsys.pdm.Adapters.PmmlVersion20.SequenceModel
     */
    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 transactId = (CategoricalAttribute) metaData.getMiningAttribute(transactIdName);
        if (! exportTransactIds) transactId.setUnboundedCategories(true);
        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);
    }

    /**
     * Creates PMML element SequenceModel.
     *
     * @return PMML object SequenceModel
     * @exception MiningException cannot create PMML object
     * @see com.prudsys.pdm.Adapters.PmmlVersion20.SequenceModel
     */
    public Object createPmmlObject() throws MiningException
    {
        SequenceModel smm = new SequenceModel();
        SequentialSettings seqset = (SequentialSettings)miningSettings;
        CategoricalAttribute cattr = (CategoricalAttribute)seqset.getTransactionId();
        int transNum = getNumberOfTransactions();
        CategoricalAttribute catit = (CategoricalAttribute)seqset.getItemId();
        int itemsNum = catit.getCategoriesNumber();
        int numberOfRules = 0;
        if (sequenceRules != null) numberOfRules = sequenceRules.size();
        smm.setNumberOfTransactions(Integer.toString(transNum));
        smm.setNumberOfSequences(Integer.toString(sequentialRules.size()));
        smm.setNumberOfRules( Integer.toString(numberOfRules) );
//        smm.setMaxNumberOfItemsPerTransaction("0");
//        smm.setAvgNumberOfItemsPerTransaction("0");
        smm.setMinimumSupport(Double.toString(seqset.getMinimumSupport()));
        smm.setMinimumConfidence(Double.toString(seqset.getMinimumConfidence()));
        smm.setNumberOfItems( Integer.toString(itemsNum) );
        smm.setNumberOfSets( Integer.toString(itemsNum) );
        smm.setAlgorithmName(algorithm);
        smm.setFunctionName("sequential");
        smm.setModelName("Sequential model");
        if (exportTransactItemNames == EXPORT_PMML_NAME_TYPE_XELOPES) {
          smm.setItemIdName( catit.getName() );
          smm.setTransactIdName( cattr.getName() );
          smm.setPositionIdName( seqset.getItemIndex().getName() );
        };
        smm.setMiningSchema( (MiningSchema)inputSpec.createPmmlObject() );
        for(int i=0;i<itemsNum;i++)
        {
          SetPredicate ssp = new SetPredicate();
          ssp.setId("sp"+i);
          ssp.setField(catit.getName());
          ssp.setOperator("supersetOf");
          ssp.setArrayText(((Category)catit.getCategory((double)i)).getDisplayValue());
          smm.addSetPredicate(ssp);
        }
        Hashtable is2id = new Hashtable();
        int seqNum = sequentialRules.size();
        for(int i=0;i<seqNum;i++)
        {
          ItemSetSeq iss = (ItemSetSeq)sequentialRules.get(i);
          Sequence seq = new Sequence();
          seq.setNumberOfSets(Integer.toString(iss.getSize()));
          String id = "seq"+i;
          seq.setId(id);
          is2id.put(iss, id);
          seq.setSupport(Double.toString(iss.getSupportCount()/(double)transNum));
          int issSize = iss.getSize();
          for(int j=0;j<issSize;j++)
          {
            SetReference ref = new SetReference();
            ref.setSetId("sp"+iss.getItemAt(j));
            if(j==0) seq.setSetReference(ref);
            else seq.addSetReference1(ref);
            if(j!=issSize-1)
            {
              Delimiter delim = new Delimiter();
              delim.setDelimiter("sameTimeWindow");
              delim.setGap("false");
              seq.addDelimiter(delim);
            }
          }
          smm.addSequence(seq);
        };

        SequenceRule[] seqRule = new SequenceRule[numberOfRules];
        for(int i = 0; i < numberOfRules; i++)
        {
          RuleSetSeq rs = (RuleSetSeq) sequenceRules.elementAt(i);
          double support    = rs.getSupport();
          double confidence = rs.getConfidence();
          int itemSize = rs.getSize();
          ItemSetSeq premise = rs.getPremise();
          ItemSetSeq conclusion = rs.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;
    }

    /**
     * Reads PMML document of sequence model.
     * PMMLs SequenceModel is used.
     *
     * @param reader reader for PMML model
     * @exception MiningException cannot read PMML document
     * @see com.prudsys.pdm.Adapters.PmmlVersion20.SequenceModel
     */
    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 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:
        SequentialSettings ars = new SequentialSettings();
        ars.setDataSpecification(newMetaData);
        setMiningSettings(ars);

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

    /**
     * Reads PMML SequenceModel.
     *
     * @param pmmlObject object of SequenceModel
     * @exception MiningException cannot parse PMML object
     * @see com.prudsys.pdm.Adapters.PmmlVersion20.SequenceModel
     */
    public void parsePmmlObject( Object pmmlObject ) throws MiningException
    {
        sequentialRules = new Vector();
        SequenceModel model = (SequenceModel)pmmlObject;
        SequentialSettings seqset = (SequentialSettings)miningSettings;
        int transNum = Integer.parseInt(model.getNumberOfTransactions());
        double supp = Double.parseDouble(model.getMinimumSupport());
        seqset.setMinimumSupport(supp);
        double conf = Double.parseDouble(model.getMinimumConfidence());
        seqset.setMinimumConfidence(conf);
        if (model.getItemIdName() != null) {
          itemIdName = model.getItemIdName();
          exportTransactItemNames = EXPORT_PMML_NAME_TYPE_XELOPES;
        };
        if (model.getTransactIdName() != null) {
          transactIdName = model.getTransactIdName();
          exportTransactItemNames = EXPORT_PMML_NAME_TYPE_XELOPES;
        };
        if (model.getPositionIdName() != null) {
          itemIndexName = model.getPositionIdName();
          exportTransactItemNames = EXPORT_PMML_NAME_TYPE_XELOPES;
        };
        MiningDataSpecification metaData = seqset.getDataSpecification();
        CategoricalAttribute transactId, itemId;
        NumericAttribute itemIndex;
        try
        {
            transactId = (CategoricalAttribute)metaData.getMiningAttribute(transactIdName);
            itemId     = (CategoricalAttribute)metaData.getMiningAttribute(itemIdName);
            itemIndex  = (NumericAttribute)metaData.getMiningAttribute(itemIndexName);
        }
        catch(ClassCastException ex)
        {
            throw new MiningException("transactionId and itemId attributes must be categorical, itemIndex numeric");
        }
        seqset.setItemId(itemId);
        seqset.setTransactionId(transactId);
        seqset.setItemIndex(itemIndex);

        MiningSchema schema = model.getMiningSchema();
        if( schema != null )
        {
            inputSpec = new ApplicationInputSpecification();
            inputSpec.parsePmmlObject( schema );
            inputSpec.initApplicationInputSpecification( seqset );
        }
        else
        {
            inputSpec = new ApplicationInputSpecification( seqset.getDataSpecification() );
            inputSpec.initApplicationInputSpecification( seqset );
        }

        SetPredicate[] preds = model.getSetPredicate();
        Hashtable items = new Hashtable();
        for(int i=0;i<preds.length;i++)
        {
            Category cat = new Category( preds[i].getArrayText(), preds[i].getArrayText(), new CategoryProperty() );
          double dbl = itemId.getKey(cat);
          items.put(preds[i].getId(),new Integer((int)dbl));
        }
        Sequence[] seqs = model.getSequence();
        Hashtable itemsetsMap = new Hashtable();
        for(int i=0;i<seqs.length;i++)
        {
          ItemSetSeq iss = new ItemSetSeq();
          supp = Double.parseDouble(seqs[i].getSupport());
          iss.setSupportCount((int)(supp*transNum+.999999));
          int setNum = Integer.parseInt(seqs[i].getNumberOfSets());
          for(int j=0;j<setNum;j++)
          {
            int val = ((Integer)items.get(seqs[i].getSetReference1(j).getSetId())).intValue();
            iss.addItem(val);
          };
          itemsetsMap.put( seqs[i].getId(), iss );
          sequentialRules.add(iss);
        };

        sequenceRules = new Vector();
        SequenceRule[] rules = model.getSequenceRule();
        for(int i=0;i<rules.length;i++)
        {
          ItemSetSeq antecedent = (ItemSetSeq)itemsetsMap.get(rules[i].getAntecedentSequence().getSequenceReference().getSeqId());
          ItemSetSeq consequent = (ItemSetSeq)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());
          RuleSetSeq rs = new RuleSetSeq(antecedent,consequent,supp2,conf2);