Source code: marf/Classification/RandomClassification/RandomClassification.java

   package marf.Classification.RandomClassification;
   
   import java.io.FileInputStream;
   import java.io.FileNotFoundException;
   import java.io.FileOutputStream;
   import java.io.ObjectInputStream;
   import java.io.ObjectOutputStream;
   import java.util.Random;
   import java.util.Vector;
  import java.util.zip.GZIPInputStream;
  import java.util.zip.GZIPOutputStream;
  
  import marf.MARF;
  import marf.Classification.Classification;
  import marf.Classification.ClassificationException;
  import marf.FeatureExtraction.IFeatureExtraction;
  import marf.Storage.Result;
  import marf.Storage.StorageException;
  import marf.util.Debug;
  
  
  /**
   * <p>Random Classification Module is for testing purposes.</p>
   *
   * <p>This represents the bottomline of the classification results.
   * All the other modules should be better than this 99% of the time.
   * If they are not, debug them.</p>
   *
   * <p>$Id: RandomClassification.java,v 1.15 2005/08/14 01:15:55 mokhov Exp $</p>
   *
   * @author Serguei Mokhov
   * @version $Revision: 1.15 $
   * @since 0.2.0
   */
  public class RandomClassification
  extends Classification
  {
    /**
     * For serialization versioning.
     * When adding new members or make other structural
     * changes regenerate this number with the
     * <code>serialver</code> tool that comes with JDK.
     * @since 0.3.0.4
     */
    private static final long serialVersionUID = -6770780209979417110L;
  
  
    /**
     * Vector of integer IDs.
     */
    private Vector oIDs = new Vector();
  
    /**
     * RandomClassification Constructor.
     * @param poFeatureExtraction FeatureExtraction module reference
     */
    public RandomClassification(IFeatureExtraction poFeatureExtraction)
    {
      super(poFeatureExtraction);
  
      this.strFilename =
        getClass().getName() + "." +
        MARF.getPreprocessingMethod() + "." +
        MARF.getFeatureExtractionMethod() + "." +
        getDefaultExtension();
    }
  
    /**
     * Picks an ID at random.
     * @return <code>true</code>
     * @throws ClassificationException
     */
    public final boolean classify()
    throws ClassificationException
    {
      try
      {
        int iFirstID = 0;
        int iSecondID = 0;
  
        restore();
  
        if(this.oIDs.size() == 0)
        {
          Debug.debug("RandomClassification.classify() --- ID set is of 0 length.");
  
          this.oIDs.add(new Integer(iFirstID));
  
          this.oResultSet.addResult
          (
            iFirstID,
            0,
            getClass().getName() +
            " out of the blue"
          );
        }
        else
        {
          // Collect for stats
         // XXX: Move to StatsCollector
         iFirstID = ((Integer)this.oIDs.elementAt((int)(this.oIDs.size() * (new Random().nextDouble())))).intValue();
         iSecondID = iFirstID;
 
         // Pick a different second best ID if there are > 1 IDs in there
         while(iSecondID == iFirstID && this.oIDs.size() > 1)
           iSecondID = ((Integer)this.oIDs.elementAt((int)(this.oIDs.size() * (new Random().nextDouble())))).intValue();
 
         // If they are still equal (in case of one ID in oIDs), just add one.
         if(iSecondID == iFirstID)
           iSecondID++;
 
         Debug.debug("RandomClassification.classify() --- ID1 = " + iFirstID + ", ID2 = " + iSecondID);
 
         this.oResultSet.addResult(iFirstID, 0, this.getClass().getName());
         this.oResultSet.addResult(iSecondID, 1, this.getClass().getName());
       }
 
       return true;
     }
     catch(StorageException e)
     {
       throw new ClassificationException(e);
     }
   }
 
   /**
    * Simply stores incoming ID's.
    * @return <code>true</code>
    * @throws ClassificationException
    */
   public final boolean train()
   throws ClassificationException
   {
     try
     {
       Integer oIntegerID = new Integer(MARF.getCurrentSubject());
 
       // TODO: this test isn't working -- objects are not the same, so dupes are possible
       // maybe need to fix, though it's not of primary importance
       if(this.oIDs.contains(oIntegerID) == false)
       {
         restore();
 
         this.oIDs.add(oIntegerID);
 
         dump();
 
         Debug.debug
         (
           "RandomClassification.train() --- added ID: " + MARF.getCurrentSubject() + ",\n" +
           "all IDs: " + this.oIDs
         );
       }
 
       return true;
     }
     catch(StorageException e)
     {
       throw new ClassificationException("Exception in RandomClassification.train() --- " + e.getMessage());
     }
   }
 
   /* From Storage Manager */
 
   /**
    * Dumps "training set" of IDs.
    * @throws StorageException
    */
   public final void dump()
   throws StorageException
   {
     try
     {
       FileOutputStream fos = new FileOutputStream(this.strFilename);
       GZIPOutputStream gzos = new GZIPOutputStream(fos);
       ObjectOutputStream out = new ObjectOutputStream(gzos);
 
       out.writeObject(this.oIDs);
       out.flush();
       out.close();
     }
     catch(Exception e)
     {
       throw new StorageException(e);
     }
   }
 
   /**
    * Restores "training set" of IDs.
    * @throws StorageException if there was an error loading the data file.
    */
   public final void restore()
   throws StorageException
   {
     try
     {
       FileInputStream fis = new FileInputStream(this.strFilename);
       GZIPInputStream gzis = new GZIPInputStream(fis);
       ObjectInputStream in = new ObjectInputStream(gzis);
 
       this.oIDs = (Vector)in.readObject();
 
       in.close();
     }
     catch(FileNotFoundException e)
     {
       this.oIDs = new Vector();
       dump();
     }
     catch(ClassNotFoundException e)
     {
       throw new StorageException
       (
         "RandomClassification.restore() --- ClassNotFoundException: " +
         e.getMessage()
       );
     }
     catch(Exception e)
     {
       throw new StorageException(e);
     }
   }
 
   /**
    * Retrieves the classification result.
    *
    * @return Result object
    *
    * @since 0.3.0
    */
   public Result getResult()
   {
     return this.oResultSet.getMinimumResult();
   }
 
   /**
    * Returns string representation of the internals of this object.
    * @return String
    * @since 0.3.0
    */
   public String toString()
   {
     return
       "Dump mode: " + this.iCurrentDumpMode + "\n" +
       "Dump file: " + this.strFilename + "\n" +
       "ID data: " + this.oIDs;
   }
 
   /**
    * Retrieves class' revision.
    * @return revision string
    * @since 0.3.0
    */
   public static String getMARFSourceCodeRevision()
   {
     return "$Revision: 1.15 $";
   }
 }
 
 // EOF