Пример #1
0
  /**
   * Accept an instance for processing by StreamableFilters only
   *
   * @param e an <code>InstanceEvent</code> value
   */
  public void acceptInstance(InstanceEvent e) {
    // to do!
    if (m_filterThread != null) {
      String messg =
          Messages.getInstance().getString("Filter_AcceptInstance_Mess_Text_First")
              + statusMessagePrefix()
              + Messages.getInstance().getString("Filter_AcceptInstance_Mess_Text_Second");
      if (m_log != null) {
        m_log.logMessage(messg);
        m_log.statusMessage(
            statusMessagePrefix()
                + Messages.getInstance()
                    .getString("Filter_AcceptInstance_StatusMessage_Text_First"));
      } else {
        System.err.println(messg);
      }
      return;
    }
    if (!(m_Filter instanceof StreamableFilter)) {
      stop(); // stop all processing
      if (m_log != null) {
        m_log.logMessage(
            Messages.getInstance().getString("Filter_AcceptInstance_LogMessage_Text_First")
                + statusMessagePrefix()
                + Messages.getInstance().getString("Filter_AcceptInstance_LogMessage_Text_Second")
                + m_Filter.getClass().getName()
                + Messages.getInstance().getString("Filter_AcceptInstance_LogMessage_Text_Third"));
        m_log.statusMessage(
            statusMessagePrefix()
                + Messages.getInstance()
                    .getString("Filter_AcceptInstance_StatusMessage_Text_Second"));
      }
      return;
    }
    if (e.getStatus() == InstanceEvent.FORMAT_AVAILABLE) {
      try {
        m_instanceCount = 0;
        // notifyInstanceListeners(e);
        //	Instances dataset = e.getInstance().dataset();
        Instances dataset = e.getStructure();
        if (m_Filter instanceof SupervisedFilter) {
          // defualt to last column if no class is set
          if (dataset.classIndex() < 0) {
            dataset.setClassIndex(dataset.numAttributes() - 1);
          }
        }
        // initialize filter
        m_Filter.setInputFormat(dataset);
        // attempt to determine post-filtering
        // structure. If successful this can be passed on to instance
        // listeners as a new FORMAT_AVAILABLE event.
        m_structurePassedOn = false;
        try {
          if (m_Filter.isOutputFormatDefined()) {
            //	    System.err.println("Filter - passing on output format...");
            //	    System.err.println(m_Filter.getOutputFormat());
            m_ie.setStructure(m_Filter.getOutputFormat());
            notifyInstanceListeners(m_ie);
            m_structurePassedOn = true;
          }
        } catch (Exception ex) {
          stop(); // stop all processing
          if (m_log != null) {
            m_log.logMessage(
                Messages.getInstance().getString("Filter_AcceptInstance_LogMessage_Text_Fourth")
                    + statusMessagePrefix()
                    + Messages.getInstance()
                        .getString("Filter_AcceptInstance_LogMessage_Text_Fifth")
                    + ex.getMessage());
            m_log.statusMessage(
                statusMessagePrefix()
                    + Messages.getInstance()
                        .getString("Filter_AcceptInstance_StatusMessage_Text_Third"));
          } else {
            System.err.println(
                Messages.getInstance().getString("Filter_AcceptInstance_Error_Text_First")
                    + statusMessagePrefix()
                    + Messages.getInstance().getString("Filter_AcceptInstance_Error_Text_Second"));
          }
        }
      } catch (Exception ex) {
        ex.printStackTrace();
      }
      return;
    }

    if (e.getStatus() == InstanceEvent.BATCH_FINISHED) {
      // get the last instance (if available)
      try {
        if (m_log != null) {
          m_log.statusMessage(
              statusMessagePrefix()
                  + Messages.getInstance()
                      .getString("Filter_AcceptInstance_StatusMessage_Text_Fourth"));
        }
        if (m_Filter.input(e.getInstance())) {
          Instance filteredInstance = m_Filter.output();
          if (filteredInstance != null) {
            if (!m_structurePassedOn) {
              // pass on the new structure first
              m_ie.setStructure(new Instances(filteredInstance.dataset(), 0));
              notifyInstanceListeners(m_ie);
              m_structurePassedOn = true;
            }

            m_ie.setInstance(filteredInstance);

            // if there are instances pending for output don't want to send
            // a batch finisehd at this point...
            // System.err.println("Filter - in batch finisehd...");
            if (m_Filter.batchFinished() && m_Filter.numPendingOutput() > 0) {
              m_ie.setStatus(InstanceEvent.INSTANCE_AVAILABLE);
            } else {
              m_ie.setStatus(e.getStatus());
            }
            notifyInstanceListeners(m_ie);
          }
        }
        if (m_log != null) {
          m_log.statusMessage(
              statusMessagePrefix()
                  + Messages.getInstance()
                      .getString("Filter_AcceptInstance_StatusMessage_Text_Fourth_Alpha"));
        }
      } catch (Exception ex) {
        stop(); // stop all processing
        if (m_log != null) {
          m_log.logMessage(
              Messages.getInstance().getString("Filter_AcceptInstance_LogMessage_Text_Sixth")
                  + statusMessagePrefix()
                  + ex.getMessage());
          m_log.statusMessage(
              statusMessagePrefix()
                  + Messages.getInstance()
                      .getString("Filter_AcceptInstance_StatusMessage_Text_Fifth"));
        }
        ex.printStackTrace();
      }

      // check for any pending instances that we might need to pass on
      try {
        if (m_Filter.batchFinished() && m_Filter.numPendingOutput() > 0) {
          if (m_log != null) {
            m_log.statusMessage(
                statusMessagePrefix()
                    + Messages.getInstance()
                        .getString("Filter_AcceptInstance_StatusMessage_Text_Sixth"));
          }
          Instance filteredInstance = m_Filter.output();
          if (filteredInstance != null) {
            if (!m_structurePassedOn) {
              // pass on the new structure first
              m_ie.setStructure(new Instances(filteredInstance.dataset(), 0));
              notifyInstanceListeners(m_ie);
              m_structurePassedOn = true;
            }

            m_ie.setInstance(filteredInstance);

            // TODO here is the problem I think
            m_ie.setStatus(InstanceEvent.INSTANCE_AVAILABLE);
            notifyInstanceListeners(m_ie);
          }
          while (m_Filter.numPendingOutput() > 0) {
            filteredInstance = m_Filter.output();
            m_ie.setInstance(filteredInstance);
            //            System.err.println("Filter - sending pending...");
            if (m_Filter.numPendingOutput() == 0) {
              m_ie.setStatus(InstanceEvent.BATCH_FINISHED);
            } else {
              m_ie.setStatus(InstanceEvent.INSTANCE_AVAILABLE);
            }
            notifyInstanceListeners(m_ie);
          }
          if (m_log != null) {
            m_log.statusMessage(
                statusMessagePrefix()
                    + Messages.getInstance()
                        .getString("Filter_AcceptInstance_StatusMessage_Text_Seventh"));
          }
        }
      } catch (Exception ex) {
        stop(); // stop all processing
        if (m_log != null) {
          m_log.logMessage(
              Messages.getInstance().getString("Filter_AcceptInstance_LogMessage_Text_Seventh")
                  + statusMessagePrefix()
                  + ex.toString());
          m_log.statusMessage(
              statusMessagePrefix()
                  + Messages.getInstance()
                      .getString("Filter_AcceptInstance_StatusMessage_Text_Eighth"));
        }
        ex.printStackTrace();
      }
    } else {
      // pass instance through the filter
      try {
        if (!m_Filter.input(e.getInstance())) {
          //          System.err.println("Filter - inputing instance into filter...");
          /* if (m_log != null) {
            m_log.logMessage("ERROR : filter not ready to output instance");
          } */

          // quietly return. Filter might be able to output some instances
          // once the batch is finished.
          return;
        }

        // collect output instance.
        Instance filteredInstance = m_Filter.output();
        if (filteredInstance == null) {
          return;
        }
        m_instanceCount++;

        if (!m_structurePassedOn) {
          // pass on the new structure first
          m_ie.setStructure(new Instances(filteredInstance.dataset(), 0));
          notifyInstanceListeners(m_ie);
          m_structurePassedOn = true;
        }

        m_ie.setInstance(filteredInstance);
        m_ie.setStatus(e.getStatus());

        if (m_log != null && (m_instanceCount % 10000 == 0)) {
          m_log.statusMessage(
              statusMessagePrefix()
                  + Messages.getInstance()
                      .getString("Filter_AcceptInstance_StatusMessage_Text_Nineth")
                  + m_instanceCount
                  + Messages.getInstance()
                      .getString("Filter_AcceptInstance_StatusMessage_Text_Tenth"));
        }
        notifyInstanceListeners(m_ie);
      } catch (Exception ex) {
        stop(); // stop all processing
        if (m_log != null) {
          m_log.logMessage(
              Messages.getInstance().getString("Filter_AcceptInstance_LogMessage_Text_Eighth")
                  + statusMessagePrefix()
                  + ex.toString());
          m_log.statusMessage(
              statusMessagePrefix()
                  + Messages.getInstance()
                      .getString("Filter_AcceptInstance_StatusMessage_Text_Eleventh"));
        }
        ex.printStackTrace();
      }
    }
  }
Пример #2
0
  /**
   * Convert a single instance over. The converted instance is added to the end of the output queue.
   *
   * @param instance the instance to convert
   * @exception Exception if an error occurs
   */
  private void convertInstance(Instance instance) throws Exception {

    Instance inst = null;
    if (instance instanceof SparseInstance) {
      double[] newVals = new double[instance.numAttributes()];
      int[] newIndices = new int[instance.numAttributes()];
      double[] vals = instance.toDoubleArray();
      int ind = 0;
      for (int j = 0; j < instance.numAttributes(); j++) {
        double value;
        if (instance.attribute(j).isNumeric()
            && (!Instance.isMissingValue(vals[j]))
            && (getInputFormat().classIndex() != j)) {

          // Just subtract the mean if the standard deviation is zero
          if (m_StdDevs[j] > 0) {
            value = (vals[j] - m_Means[j]) / m_StdDevs[j];
          } else {
            value = vals[j] - m_Means[j];
          }
          if (Double.isNaN(value)) {
            throw new Exception(
                "A NaN value was generated "
                    + "while standardizing attribute "
                    + instance.attribute(j).name());
          }
          if (value != 0.0) {
            newVals[ind] = value;
            newIndices[ind] = j;
            ind++;
          }
        } else {
          value = vals[j];
          if (value != 0.0) {
            newVals[ind] = value;
            newIndices[ind] = j;
            ind++;
          }
        }
      }
      double[] tempVals = new double[ind];
      int[] tempInd = new int[ind];
      System.arraycopy(newVals, 0, tempVals, 0, ind);
      System.arraycopy(newIndices, 0, tempInd, 0, ind);
      inst = new SparseInstance(instance.weight(), tempVals, tempInd, instance.numAttributes());
    } else {
      double[] vals = instance.toDoubleArray();
      for (int j = 0; j < getInputFormat().numAttributes(); j++) {
        if (instance.attribute(j).isNumeric()
            && (!Instance.isMissingValue(vals[j]))
            && (getInputFormat().classIndex() != j)) {

          // Just subtract the mean if the standard deviation is zero
          if (m_StdDevs[j] > 0) {
            vals[j] = (vals[j] - m_Means[j]) / m_StdDevs[j];
          } else {
            vals[j] = (vals[j] - m_Means[j]);
          }
          if (Double.isNaN(vals[j])) {
            throw new Exception(
                "A NaN value was generated "
                    + "while standardizing attribute "
                    + instance.attribute(j).name());
          }
        }
      }
      inst = new Instance(instance.weight(), vals);
    }
    inst.setDataset(instance.dataset());
    push(inst);
  }