supportvectorminingmodel.java

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

/*
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/**
 * Title: XELOPES Data Mining Library
 * Description: The XELOPES library is an open platform-independent and data-source-independent library for Embedded Data Mining.
 * Copyright: Copyright (c) 2002 Prudential Systems Software GmbH
 * Company: ZSoft (www.zsoft.ru), Prudsys (www.prudsys.com)
 * @author Valentine Stepanenko ([e-mail])
 * @version 1.0
 */

package com.prudsys.pdm.Models.Regression.SVM;

import java.io.PrintStream;
import java.io.Reader;
import java.io.Writer;
import java.util.Enumeration;
import java.util.Hashtable;

import com.prudsys.pdm.Adapters.PmmlVersion20.AttributeInstance;
import com.prudsys.pdm.Adapters.PmmlVersion20.Coefficient;
import com.prudsys.pdm.Adapters.PmmlVersion20.Coefficients;
import com.prudsys.pdm.Adapters.PmmlVersion20.DataDictionary;
import com.prudsys.pdm.Adapters.PmmlVersion20.Header;
import com.prudsys.pdm.Adapters.PmmlVersion20.LinearKernelType;
import com.prudsys.pdm.Adapters.PmmlVersion20.MiningSchema;
import com.prudsys.pdm.Adapters.PmmlVersion20.PMML;
import com.prudsys.pdm.Adapters.PmmlVersion20.PolynomialKernelType;
import com.prudsys.pdm.Adapters.PmmlVersion20.RadialBasisKernelType;
import com.prudsys.pdm.Adapters.PmmlVersion20.SigmoidKernelType;
import com.prudsys.pdm.Adapters.PmmlVersion20.SupportVector;
import com.prudsys.pdm.Adapters.PmmlVersion20.SupportVectorMachineModel;
import com.prudsys.pdm.Adapters.PmmlVersion20.SupportVectors;
import com.prudsys.pdm.Adapters.PmmlVersion20.TransformationDictionary;
import com.prudsys.pdm.Adapters.PmmlVersion20.VectorDictionary;
import com.prudsys.pdm.Adapters.PmmlVersion20.VectorInstance;
import com.prudsys.pdm.Core.ApplicationInputSpecification;
import com.prudsys.pdm.Core.CategoricalAttribute;
import com.prudsys.pdm.Core.MiningAttribute;
import com.prudsys.pdm.Core.MiningDataSpecification;
import com.prudsys.pdm.Core.MiningException;
import com.prudsys.pdm.Core.MiningModel;
import com.prudsys.pdm.Input.MiningVector;
import com.prudsys.pdm.Models.Regression.RegressionMiningModel;
import com.prudsys.pdm.Transform.MiningTransformationActivity;
import com.prudsys.pdm.Utils.PmmlUtils;

/**
  * Description of the data produced by a Support Vector Machine (SVM)
  * mining function. <p>
  *
  * The following kernel function are supported: <br>
  *   0 -- linear: u'*v\n, <br>
  *   1 -- polynomial: (gamma*u'*v + coef0)^degree, <br>
  *   2 -- radial basis function: exp(-gamma*|u-v|^2), <br>
  *   3 -- sigmoid: tanh(gamma*u'*v + coef0). <p>
  *
  * From PDM CWM extension. <p>
  *
  * Superclasses:
  * <ul>
  *   <li> RegressionMiningModel
  * </ul>
  * Attributes:
  * <ul>
  *   <li> <i>svmType</i>: Defines the type of SVM. The following types
  *   are predefined: SvmCSvc, SvmNuSvc, SvmOneClass, SvmEpsilonSvr, SvmNuSvr. <br>
  *     - type: Integer <br>
  *     - multiplicity: exactly one
  *   <li> <i>kernelType</i>: Defines the kernel type of the SVM. The following types
  *   are predefined: KernelLinear, KernelPoly, KernelRbf, KernelSigmoid. <br>
  *     - type: Integer <br>
  *     - multiplicity: exactly one
  *   <li> <i>degree</i>: Degree in kernel function. <br>
  *     - type: Float <br>
  *     - multiplicity: exactly one
  *   <li> <i>gamma</i>: Gamma in kernel function. <br>
  *     - type: Float <br>
  *     - multiplicity: exactly one
  *   <li> <i>coef0</i>: Coefficient coef0 in kernel function. <br>
  *     - type: float <br>
  *     - multiplicity: exactly one
  *   <li> <i>supportVectors</i>: Array of all Support Vectors. <br>
  *     - type: MiningVector <br>
  *     - multilplicity: one or more
  *   <li> <i>coefficients</i>: Coefficients of Support Vectors. <br>
  *     - type: Float <br>
  *     - multiplicity: one or more
  *   <li> <i>absoluteCoefficient</i>: Absolute coefficient in SV function. <br>
  *     - type: Float <br>
  *     - multiplicity: exactly one
  * </ul>
  * Constraints:
  * <ul>
  *   <li> number of supportVectors must be equal to number of coefficients.
  * </ul>
  *
  * In addition, functionality from extended PMML was added.
  * It corresponds to the PMML element SupportVectorMachineModel.
  *
  * @see MiningModel
  * @see com.prudsys.pdm.Models.Supervised.SupervisedMiningModel
  * @see com.prudsys.pdm.Adapters.PmmlVersion20.SupportVectorMachineModel
  */
public class SupportVectorMiningModel extends RegressionMiningModel
{
  // -----------------------------------------------------------------------
  //  Variables declarations
  // -----------------------------------------------------------------------
  // SVM types:
  private int svmType    = SupportVectorSettings.SVM_C_SVC;
  private int kernelType = SupportVectorSettings.KERNEL_RBF;

  // Kernel parameters:
  private double degree = 3.0;
  private double gamma  = 1.0;
  private double coef0  = 0.0;

  // Solution coefficients:
  private Hashtable globalSupportVectors = new Hashtable();
  private MiningVector[] supportVectors;
  private double[] coefficients;
  private double absoluteCoefficient;

  // -----------------------------------------------------------------------
  //  Constructor
  // -----------------------------------------------------------------------
  /**
   * Constructor sets function and algorithm parameters.
   */
  public SupportVectorMiningModel()
  {
    function  = MiningModel.REGRESSION_FUNCTION;
    algorithm = MiningModel.SUPPORT_VECTOR_MACHINE_ALGORITHM;
  }

  // -----------------------------------------------------------------------
  //  Getter and setter methods
  // -----------------------------------------------------------------------
  // SVM type
  public int getSvmType()
  {
    return svmType;
  }
  public void setSvmType(int svmType)
  {
    this.svmType = svmType;
  }

  // kernel type
  public int getKernelType()
  {
    return kernelType;
  }
  public void setKernelType(int kernelType)
  {
    this.kernelType = kernelType;
  }

  // support vectors
  public Hashtable getGlobalSupportVectors()
  {
    return globalSupportVectors;
  }
  public void setGlobalSupportVectors(Hashtable globalSupportVectors)
  {
    this.globalSupportVectors = globalSupportVectors;
  }
  public void setSupportVectors(com.prudsys.pdm.Input.MiningVector[] supportVectors)
  {
    this.supportVectors = supportVectors;
  }
  public com.prudsys.pdm.Input.MiningVector getSupportVector(int index)
  {
    return supportVectors[index];
  }
  public int getSupportVectorsNumber()
  {
    return supportVectors.length;
  }

  // coefficients
  public double getCoefficient(int index)
  {
    return coefficients[index];
  }
  public void setCoefficients(double[] coefficients)
  {
    this.coefficients = coefficients;
  }
  public int getCoefficientsNumber()
  {
    return coefficients.length;
  }
  public double getAbsoluteCoefficient()
  {
    return absoluteCoefficient;
  }
  public void setAbsoluteCoefficient(double absoluteCoefficient)
  {
    this.absoluteCoefficient = absoluteCoefficient;
  }

  // parameters
  public double getDegree()
  {
    return degree;
  }
  public void setDegree(double degree)
  {
    this.degree = degree;
  }
  public double getGamma()
  {
    return gamma;
  }
  public void setGamma(double gamma)
  {
    this.gamma = gamma;
  }
  public double getCoef0()
  {
    return coef0;
  }
  public void setCoef0(double coef0)
  {
    this.coef0 = coef0;
  }

  // -----------------------------------------------------------------------
  //  Methods of PMML handling
  // -----------------------------------------------------------------------
  /**
   * Creates PMML document of support vector machine model.
   * PMMLs SupportVectorMachineModel is used.
   *
   * @param writer writer for PMML model
   * @exception MiningException could not write PMML model
   * @see com.prudsys.pdm.Adapters.PmmlVersion20.SupportVectorMachineModel
   */
  public void writePmml(Writer writer) throws MiningException
  {
    PMML pmml = new PMML();
    pmml.setVersion( "2.0" );
    pmml.setHeader( (Header)PmmlUtils.getHeader() );

    // Add data and transformation dictionary:
    MiningDataSpecification metaData = miningSettings.getDataSpecification();
    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() );
    };

    // Add support vector dictionary:
    VectorDictionary vdic = new VectorDictionary();
    globalSupportVectors.clear();
    int nSupp = 0;
    if (supportVectors != null) nSupp = supportVectors.length;
    vdic.setNumberOfVectors( String.valueOf(nSupp) );
    for (int i = 0; i < nSupp; i++)
    {
      MiningVector mv    = supportVectors[i];
      String mvId        = "mv" + String.valueOf(i);
      globalSupportVectors.put(mvId, mv);
      VectorInstance xmv = new VectorInstance();
      xmv.setId(mvId);
      for (int j = 0; j < metaData.getAttributesNumber(); j++)
      {
        MiningAttribute ma = metaData.getMiningAttribute(j);
        AttributeInstance xma = new AttributeInstance();
        xma.setName( ma.getName() );
        xma.setValue( Double.toString( mv.getValue(j) ) );
        xmv.addAttributeInstance( xma );
      };
      vdic.addVectorInstance(xmv);
    };
    pmml.setVectorDictionary(vdic);

    // Add SVM model:
    pmml.addSupportVectorMachineModel( (SupportVectorMachineModel)createPmmlObject());

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

  /**
   * Creates PMML element SupportVectorMachineModel.
   *
   * @return PMML object SupportVectorMachineModel
   * @exception MiningException could not create PMML model
   * @see com.prudsys.pdm.Adapters.PmmlVersion20.SupportVectorMachineModel
   */
  public Object createPmmlObject() throws MiningException
  {
    SupportVectorMachineModel svmm = new SupportVectorMachineModel();

    // Add mining schema:
    svmm.setMiningSchema( (MiningSchema)inputSpec.createPmmlObject() );

    // Set name and SVM type:
    svmm.setModelName("Support vectors machine model");
    svmm.setFunctionName("regression");
    svmm.setAlgorithmName(algorithm);
    switch(svmType)
    {
      case SupportVectorSettings.SVM_C_SVC: svmm.setSvmType("C_SVC"); break;
      case SupportVectorSettings.SVM_EPSILON_SVR: svmm.setSvmType("EPSILON_SVR"); break;
      case SupportVectorSettings.SVM_NU_SVC: svmm.setSvmType("NU_SVC"); break;
      case SupportVectorSettings.SVM_NU_SVR: svmm.setSvmType("NU_SVR"); break;
      case SupportVectorSettings.SVM_ONE_CLASS: svmm.setSvmType("ONE_CLASS_SVM"); break;
      default: throw new MiningException("unknown SVM type");
    };

    // Set kernal type:
    switch(kernelType)
    {
      case SupportVectorSettings.KERNEL_LINEAR:
        LinearKernelType lkt = new LinearKernelType();
        lkt.setDescription("Linear kernel type");