databaseresultproducer.java

wekaUT是 university texas austin 开发的基于weka的半指导学习(semi supervised learning)的分类器

/*
 *    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.
 */

/*
 *    DatabaseResultProducer.java
 *    Copyright (C) 1999 Len Trigg
 *
 */


package weka.experiment;

import java.io.*;
import java.util.*;
import java.sql.*;
import java.net.*;
import weka.core.OptionHandler;
import weka.core.Instances;
import weka.core.FastVector;
import weka.core.Utils;
import weka.core.Option;
import weka.core.AdditionalMeasureProducer;

/**
 * DatabaseResultProducer examines a database and extracts out
 * the results produced by the specified ResultProducer
 * and submits them to the specified ResultListener. If a result needs
 * to be generated, the ResultProducer is used to obtain the result.
 *
 * @author Len Trigg ([e-mail])
 * @version $Revision: 1.1.1.1 $
 */
public class DatabaseResultProducer extends DatabaseResultListener
  implements ResultProducer, OptionHandler, AdditionalMeasureProducer {

  /** The dataset of interest */
  protected Instances m_Instances;

  /** The ResultListener to send results to */
  protected ResultListener m_ResultListener = new CSVResultListener();

  /** The ResultProducer used to generate results */
  protected ResultProducer m_ResultProducer
    = new CrossValidationResultProducer();

  /** The names of any additional measures to look for in SplitEvaluators */
  protected String [] m_AdditionalMeasures = null;

  /**
   * Returns a string describing this result producer
   * @return a description of the result producer suitable for
   * displaying in the explorer/experimenter gui
   */
  public String globalInfo() {
    return "Examines a database and extracts out "
      +"the results produced by the specified ResultProducer "
      +"and submits them to the specified ResultListener. If a result needs "
      +"to be generated, the ResultProducer is used to obtain the result.";
  }

  /**
   * Creates the DatabaseResultProducer, letting the parent constructor do
   * it's thing.
   *
   * @exception Exception if an error occurs
   */
  public DatabaseResultProducer() throws Exception {

    super();
  }
  
  /**
   * Gets the keys for a specified run number. Different run
   * numbers correspond to different randomizations of the data. Keys
   * produced should be sent to the current ResultListener
   *
   * @param run the run number to get keys for.
   * @exception Exception if a problem occurs while getting the keys
   */
  public void doRunKeys(int run) throws Exception {

    if (m_ResultProducer == null) {
      throw new Exception("No ResultProducer set");
    }
    if (m_ResultListener == null) {
      throw new Exception("No ResultListener set");
    }
    if (m_Instances == null) {
      throw new Exception("No Instances set");
    }

    // Tell the resultproducer to send results to us
    m_ResultProducer.setResultListener(this);
    m_ResultProducer.setInstances(m_Instances);
    m_ResultProducer.doRunKeys(run);
  }

  /**
   * Gets the results for a specified run number. Different run
   * numbers correspond to different randomizations of the data. Results
   * produced should be sent to the current ResultListener
   *
   * @param run the run number to get results for.
   * @exception Exception if a problem occurs while getting the results
   */
  public void doRun(int run) throws Exception {

    if (m_ResultProducer == null) {
      throw new Exception("No ResultProducer set");
    }
    if (m_ResultListener == null) {
      throw new Exception("No ResultListener set");
    }
    if (m_Instances == null) {
      throw new Exception("No Instances set");
    }

    // Tell the resultproducer to send results to us
    m_ResultProducer.setResultListener(this);
    m_ResultProducer.setInstances(m_Instances);
    m_ResultProducer.doRun(run);

  }
  
  /**
   * Prepare for the results to be received.
   *
   * @param rp the ResultProducer that will generate the results
   * @exception Exception if an error occurs during preprocessing.
   */
  public void preProcess(ResultProducer rp) throws Exception {

    super.preProcess(rp);
    if (m_ResultListener == null) {
      throw new Exception("No ResultListener set");
    }
    m_ResultListener.preProcess(this);
  }

  /**
   * When this method is called, it indicates that no more results
   * will be sent that need to be grouped together in any way.
   *
   * @param rp the ResultProducer that generated the results
   * @exception Exception if an error occurs
   */
  public void postProcess(ResultProducer rp) throws Exception {

    super.postProcess(rp);
    m_ResultListener.postProcess(this);
  }
  
  /**
   * Prepare to generate results. The ResultProducer should call
   * preProcess(this) on the ResultListener it is to send results to.
   *
   * @exception Exception if an error occurs during preprocessing.
   */
  public void preProcess() throws Exception {
    
    if (m_ResultProducer == null) {
      throw new Exception("No ResultProducer set");
    }
    m_ResultProducer.setResultListener(this);
    m_ResultProducer.preProcess();
  }
  
  /**
   * When this method is called, it indicates that no more requests to
   * generate results for the current experiment will be sent. The
   * ResultProducer should call preProcess(this) on the
   * ResultListener it is to send results to.
   *
   * @exception Exception if an error occurs
   */
  public void postProcess() throws Exception {

    m_ResultProducer.postProcess();
  }
    
  /**
   * Accepts results from a ResultProducer.
   *
   * @param rp the ResultProducer that generated the results
   * @param key an array of Objects (Strings or Doubles) that uniquely
   * identify a result for a given ResultProducer with given compatibilityState
   * @param result the results stored in an array. The objects stored in
   * the array may be Strings, Doubles, or null (for the missing value).
   * @exception Exception if the result could not be accepted.
   */
  public void acceptResult(ResultProducer rp, Object [] key, Object [] result)
    throws Exception {

    if (m_ResultProducer != rp) {
      throw new Error("Unrecognized ResultProducer sending results!!");
    }
    //    System.err.println("DBRP::acceptResult");

    // Is the result needed by the listener?
    boolean isRequiredByListener = m_ResultListener.isResultRequired(this,
								     key);
    // Is the result already in the database?
    boolean isRequiredByDatabase = super.isResultRequired(rp, key);

    // Insert it into the database here
    if (isRequiredByDatabase) {
      // We could alternatively throw an exception if we only want values
      // that are already in the database
      if (result != null) {

	// null result could occur from a chain of doRunKeys calls
	super.acceptResult(rp, key, result);
      }
    }

    // Pass it on
    if (isRequiredByListener) {
      m_ResultListener.acceptResult(this, key, result);
    }
  }

  /**
   * Determines whether the results for a specified key must be
   * generated.
   *
   * @param rp the ResultProducer wanting to generate the results
   * @param key an array of Objects (Strings or Doubles) that uniquely
   * identify a result for a given ResultProducer with given compatibilityState
   * @return true if the result should be generated
   * @exception Exception if it could not be determined if the result 
   * is needed.
   */
  public boolean isResultRequired(ResultProducer rp, Object [] key) 
    throws Exception {

    if (m_ResultProducer != rp) {
      throw new Error("Unrecognized ResultProducer sending results!!");
    }
    //    System.err.println("DBRP::isResultRequired");

    // Is the result needed by the listener?
    boolean isRequiredByListener = m_ResultListener.isResultRequired(this,
								     key);
    // Is the result already in the database?
    boolean isRequiredByDatabase = super.isResultRequired(rp, key);

    if (!isRequiredByDatabase && isRequiredByListener) {
      // Pass the result through to the listener
      Object [] result = getResultFromTable(m_ResultsTableName,
					    rp, key);
      System.err.println("Got result from database: "
			 + DatabaseUtils.arrayToString(result));
      m_ResultListener.acceptResult(this, key, result);
      return false;
    }

    return (isRequiredByListener || isRequiredByDatabase);
  }

  /**
   * Gets the names of each of the columns produced for a single run.
   *
   * @return an array containing the name of each column
   * @exception Exception if something goes wrong.
   */
  public String [] getKeyNames() throws Exception {

    return m_ResultProducer.getKeyNames();
  }

  /**
   * Gets the data types of each of the columns produced for a single run.
   * This method should really be static.
   *
   * @return an array containing objects of the type of each column. The 
   * objects should be Strings, or Doubles.