Example usage for weka.core SerializedObject getObject

List of usage examples for weka.core SerializedObject getObject

  1. HOME
  2. Java
  3. weka
  4. weka.core.*
  5. SerializedObject
  6. getObject

Introduction

In this page you can find the example usage for weka.core SerializedObject getObject.

Prototype

public Object getObject()

Source Link

Document

Returns a serialized object.

Usage

From source file:meka.classifiers.multilabel.AbstractMultiLabelClassifier.java

License:Open Source License

/**
 * Creates a given number of deep copies of the given multi-label classifier using serialization.
 *
 * @param model the classifier to copy//from w  ww . j  a  va  2 s. c  o m
 * @param num the number of classifier copies to create.
 * @return an array of classifiers.
 * @exception Exception if an error occurs
 */
public static MultiLabelClassifier[] makeCopies(MultiLabelClassifier model, int num) throws Exception {

    if (model == null) {
        throw new Exception("No model classifier set");
    }
    MultiLabelClassifier classifiers[] = new MultiLabelClassifier[num];
    SerializedObject so = new SerializedObject(model);
    for (int i = 0; i < classifiers.length; i++) {
        classifiers[i] = (MultiLabelClassifier) so.getObject();
    }
    return classifiers;
}

From source file:meka.classifiers.multilabel.ProblemTransformationMethod.java

License:Open Source License

/**
 * Creates a given number of deep copies of the given multi-label classifier using serialization.
 *
 * @param model the classifier to copy/*  ww w  .java2  s  .c  om*/
 * @param num the number of classifier copies to create.
 * @return an array of classifiers.
 * @exception Exception if an error occurs
 */
public static ProblemTransformationMethod[] makeCopies(ProblemTransformationMethod model, int num)
        throws Exception {

    if (model == null) {
        throw new Exception("No model classifier set");
    }
    ProblemTransformationMethod classifiers[] = new ProblemTransformationMethod[num];
    SerializedObject so = new SerializedObject(model);
    for (int i = 0; i < classifiers.length; i++) {
        classifiers[i] = (ProblemTransformationMethod) so.getObject();
    }
    return classifiers;
}

From source file:meka.core.ObjectUtils.java

License:Open Source License

/**
 * Creates a deep copy of the given object (must be serializable!). Returns
 * null in case of an error./*w w  w. j  ava  2  s . co m*/
 *
 * @param o      the object to copy
 * @return      the deep copy
 */
public static Object deepCopy(Object o) {
    Object result;
    SerializedObject so;

    try {
        so = new SerializedObject((Serializable) o);
        result = so.getObject();
    } catch (Exception e) {
        System.err.println("Failed to serialize " + o.getClass().getName() + ":");
        e.printStackTrace();
        result = null;
    }

    return result;
}

From source file:milk.classifiers.MIClassifier.java

License:Open Source License

/**
 * Creates copies of the current classifier, which can then
 * be used for boosting etc. Note that this method now uses
 * Serialization to perform a deep copy, so the Classifier
 * object must be fully Serializable. Any currently built model
 * will now be copied as well.//from w  w w  .  ja v a 2  s .  c om
 *
 * @param model an example classifier to copy
 * @param num the number of classifiers copies to create.
 * @return an array of MI-classifiers.
 * @exception Exception if an error occurs
 */
public static MIClassifier[] makeCopies(MIClassifier model, int num) throws Exception {

    if (model == null) {
        throw new Exception("No model classifier set");
    }
    MIClassifier[] classifiers = new MIClassifier[num];
    SerializedObject so = new SerializedObject(model);
    for (int i = 0; i < classifiers.length; i++) {
        classifiers[i] = (MIClassifier) so.getObject();
    }
    return classifiers;
}

From source file:milk.experiment.MIRemoteExperiment.java

License:Open Source License

/**
   * Prepares a remote experiment for running, creates sub experiments
   *//  w  w w  .jav a2s . c  om
   * @exception Exception if an error occurs
   */
  public void initialize() throws Exception {
      if (m_baseExperiment == null) {
          throw new Exception("No base experiment specified!");
      }

      m_experimentAborted = false;
      m_finishedCount = 0;
      m_failedCount = 0;
      m_RunNumber = getRunLower();
      m_DatasetNumber = 0;
      m_PropertyNumber = 0;
      m_CurrentProperty = -1;
      m_CurrentInstances = null;
      m_Finished = false;

      if (m_remoteHosts.size() == 0) {
          throw new Exception("No hosts specified!");
      }
      // initialize all remote hosts to available
      m_remoteHostsStatus = new int[m_remoteHosts.size()];
      m_remoteHostFailureCounts = new int[m_remoteHosts.size()];

      m_remoteHostsQueue = new Queue();
      // prime the hosts queue
      for (int i = 0; i < m_remoteHosts.size(); i++) {
          m_remoteHostsQueue.push(new Integer(i));
      }

      // set up sub experiments
      m_subExpQueue = new Queue();
      int numExps;
      if (getSplitByDataSet()) {
          numExps = m_baseExperiment.getDatasets().size();
      } else {
          numExps = getRunUpper() - getRunLower() + 1;
      }
      m_subExperiments = new MIExperiment[numExps];
      m_subExpComplete = new int[numExps];
      // create copy of base experiment
      SerializedObject so = new SerializedObject(m_baseExperiment);

      if (getSplitByDataSet()) {
          for (int i = 0; i < m_baseExperiment.getDatasets().size(); i++) {
              m_subExperiments[i] = (MIExperiment) so.getObject();
              // one for each data set
              DefaultListModel temp = new DefaultListModel();
              temp.addElement(m_baseExperiment.getDatasets().elementAt(i));
              m_subExperiments[i].setDatasets(temp);
              m_subExpQueue.push(new Integer(i));
          }
      } else {
          for (int i = getRunLower(); i <= getRunUpper(); i++) {
              m_subExperiments[i - getRunLower()] = (MIExperiment) so.getObject();
              // one run for each sub experiment
              m_subExperiments[i - getRunLower()].setRunLower(i);
              m_subExperiments[i - getRunLower()].setRunUpper(i);

              m_subExpQueue.push(new Integer(i - getRunLower()));
          }
      }
  }

From source file:mulan.data.LabelsMetaDataImpl.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override//from www .  java  2  s .c om
public LabelsMetaData clone() {
    Set<LabelNode> rootNodes = null;
    try {
        SerializedObject obj = new SerializedObject(rootLabelNodes);
        rootNodes = (Set<LabelNode>) obj.getObject();
    } catch (Exception ex) {
        throw new WekaException("Failed to create copy of 'root label nodes'.", ex);
    }

    LabelsMetaDataImpl copyResult = new LabelsMetaDataImpl();
    for (LabelNode rootNode : rootNodes) {
        copyResult.addRootNode(rootNode);
    }

    return copyResult;
}

From source file:org.pentaho.di.scoring.WekaScoring.java

License:Open Source License

/**
 * Process an incoming row of data./*  w  ww  . jav  a  2  s  .  c  o  m*/
 *
 * @param smi a <code>StepMetaInterface</code> value
 * @param sdi a <code>StepDataInterface</code> value
 * @return a <code>boolean</code> value
 * @throws KettleException if an error occurs
 */
@Override
public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {

    m_meta = (WekaScoringMeta) smi;
    m_data = (WekaScoringData) sdi;

    Object[] r = getRow();

    if (r == null) {
        if (m_data.getModel().isBatchPredictor() && !m_meta.getFileNameFromField() && m_batch.size() > 0) {
            try {
                outputBatchRows();
            } catch (Exception ex) {
                throw new KettleException(BaseMessages.getString(WekaScoringMeta.PKG,
                        "WekaScoring.Error.ProblemWhileGettingPredictionsForBatch"), ex); //$NON-NLS-1$
            }
        }

        // see if we have an incremental model that is to be saved somewhere.
        if (!m_meta.getFileNameFromField() && m_meta.getUpdateIncrementalModel()) {
            if (!Const.isEmpty(m_meta.getSavedModelFileName())) {
                // try and save that sucker...
                try {
                    String modName = environmentSubstitute(m_meta.getSavedModelFileName());
                    File updatedModelFile = null;
                    if (modName.startsWith("file:")) { //$NON-NLS-1$
                        try {
                            modName = modName.replace(" ", "%20"); //$NON-NLS-1$ //$NON-NLS-2$
                            updatedModelFile = new File(new java.net.URI(modName));
                        } catch (Exception ex) {
                            throw new KettleException(BaseMessages.getString(WekaScoringMeta.PKG,
                                    "WekaScoring.Error.MalformedURIForUpdatedModelFile"), ex); //$NON-NLS-1$
                        }
                    } else {
                        updatedModelFile = new File(modName);
                    }
                    WekaScoringData.saveSerializedModel(m_data.getModel(), updatedModelFile);
                } catch (Exception ex) {
                    throw new KettleException(BaseMessages.getString(WekaScoringMeta.PKG,
                            "WekaScoring.Error.ProblemSavingUpdatedModelToFile"), ex); //$NON-NLS-1$
                }
            }
        }

        if (m_meta.getFileNameFromField()) {
            // clear the main model
            m_data.setModel(null);
        } else {
            m_data.getModel().done();
        }

        setOutputDone();
        return false;
    }

    // Handle the first row
    if (first) {
        first = false;

        m_data.setOutputRowMeta(getInputRowMeta().clone());
        if (m_meta.getFileNameFromField()) {
            RowMetaInterface inputRowMeta = getInputRowMeta();

            m_indexOfFieldToLoadFrom = inputRowMeta.indexOfValue(m_meta.getFieldNameToLoadModelFrom());

            if (m_indexOfFieldToLoadFrom < 0) {
                throw new KettleException("Unable to locate model file field " //$NON-NLS-1$
                        + m_meta.getFieldNameToLoadModelFrom() + " in the incoming stream!"); //$NON-NLS-1$
            }

            if (!inputRowMeta.getValueMeta(m_indexOfFieldToLoadFrom).isString()) {
                throw new KettleException(BaseMessages.getString(WekaScoringMeta.PKG, "WekaScoring.Error.")); //$NON-NLS-1$
            }

            if (m_meta.getCacheLoadedModels()) {
                m_modelCache = new HashMap<String, WekaScoringModel>();
            }

            // set the default model
            if (!Const.isEmpty(m_meta.getSerializedModelFileName())) {
                WekaScoringModel defaultModel = setModel(m_meta.getSerializedModelFileName());

                m_data.setDefaultModel(defaultModel);
            } else if (m_meta.getModel() != null) {
                try {
                    SerializedObject so = new SerializedObject(m_meta.getModel());
                    WekaScoringModel defaultModel = (WekaScoringModel) so.getObject();

                    m_data.setDefaultModel(defaultModel);
                } catch (Exception ex) {
                    throw new KettleException(ex);
                }
            }

            // set the main model from this row
            setModelFromField(r);
            logBasic(BaseMessages.getString(WekaScoringMeta.PKG,
                    "WekaScoring.Message.SourcingModelNamesFromInputField", //$NON-NLS-1$
                    m_meta.getFieldNameToLoadModelFrom()));
        } else if (m_meta.getModel() == null || !Const.isEmpty(m_meta.getSerializedModelFileName())) {
            // If we don't have a model, or a file name is set, then load from file

            // Check that we have a file to try and load a classifier from
            if (Const.isEmpty(m_meta.getSerializedModelFileName())) {
                throw new KettleException(BaseMessages.getString(WekaScoringMeta.PKG,
                        "WekaScoring.Error.NoFilenameToLoadModelFrom")); //$NON-NLS-1$
            }

            setModel(m_meta.getSerializedModelFileName());
        } else if (m_meta.getModel() != null) {
            // copy the primary model over to the data class
            try {
                SerializedObject so = new SerializedObject(m_meta.getModel());
                WekaScoringModel defaultModel = (WekaScoringModel) so.getObject();

                m_data.setModel(defaultModel);
            } catch (Exception ex) {
                throw new KettleException(ex);
            }
        }

        // Check the input row meta data against the instances
        // header that the classifier was trained with
        try {
            Instances header = m_data.getModel().getHeader();
            m_data.mapIncomingRowMetaData(header, getInputRowMeta(), m_meta.getUpdateIncrementalModel(), log);
        } catch (Exception ex) {
            throw new KettleException(BaseMessages.getString(WekaScoringMeta.PKG,
                    "WekaScoring.Error.IncomingDataFormatDoesNotMatchModel"), ex); //$NON-NLS-1$
        }

        // Determine the output format
        m_meta.getFields(m_data.getOutputRowMeta(), getStepname(), null, null, this);

        if (!Const.isEmpty(m_meta.getBatchScoringSize())) {
            try {
                String bss = environmentSubstitute(m_meta.getBatchScoringSize());
                m_batchScoringSize = Integer.parseInt(bss);
            } catch (NumberFormatException ex) {
                String modelPreferred = environmentSubstitute(
                        ((BatchPredictor) m_meta.getModel().getModel()).getBatchSize());

                boolean sizeOk = false;
                if (!Const.isEmpty(modelPreferred)) {
                    logBasic(BaseMessages.getString(WekaScoringMeta.PKG,
                            "WekaScoring.Message.UnableToParseBatchScoringSize", //$NON-NLS-1$
                            modelPreferred));
                    try {
                        m_batchScoringSize = Integer.parseInt(modelPreferred);
                        sizeOk = true;
                    } catch (NumberFormatException e) {
                        // ignore
                    }
                }

                if (!sizeOk) {
                    logBasic(BaseMessages.getString(WekaScoringMeta.PKG,
                            "WekaScoring.Message.UnableToParseBatchScoringSizeDefault",
                            //$NON-NLS-1$
                            WekaScoringMeta.DEFAULT_BATCH_SCORING_SIZE));

                    m_batchScoringSize = WekaScoringMeta.DEFAULT_BATCH_SCORING_SIZE;
                }
            }
        }

        if (m_data.getModel().isBatchPredictor()) {
            m_batch = new ArrayList<Object[]>();
        }
    } // end (if first)

    // Make prediction for row using model
    try {
        if (m_meta.getFileNameFromField()) {
            setModelFromField(r);
        }

        if (m_data.getModel().isBatchPredictor() && !m_meta.getFileNameFromField()) {
            try {
                // add current row to batch
                m_batch.add(r);

                if (m_batch.size() == m_batchScoringSize) {
                    outputBatchRows();
                }
            } catch (Exception ex) {
                throw new KettleException(BaseMessages.getString(WekaScoringMeta.PKG,
                        "WekaScoring.Error.ErrorGettingBatchPredictions"), ex); //$NON-NLS-1$
            }
        } else {
            Object[] outputRow = m_data.generatePrediction(getInputRowMeta(), m_data.getOutputRowMeta(), r,
                    m_meta);
            putRow(m_data.getOutputRowMeta(), outputRow);
        }
    } catch (Exception ex) {
        throw new KettleException(BaseMessages.getString(WekaScoringMeta.PKG,
                "WekaScoring.Error.UnableToMakePredictionForRow", getLinesRead()), ex); //$NON-NLS-1$
    }

    if (log.isRowLevel()) {
        log.logRowlevel(toString(), "Read row #" + getLinesRead() + " : " + r); //$NON-NLS-1$ //$NON-NLS-2$
    }

    if (checkFeedback(getLinesRead())) {
        logBasic("Linenr " + getLinesRead()); //$NON-NLS-1$
    }
    return true;
}

From source file:org.pentaho.di.scoring.WekaScoringMeta.java

License:Open Source License

/**
 * Clone this step's meta data/*from  w  w w .  jav a2s.c  om*/
 *
 * @return the cloned meta data
 */
@Override
public Object clone() {
    WekaScoringMeta retval = (WekaScoringMeta) super.clone();
    // deep copy the model (if any)
    if (m_model != null) {
        try {
            SerializedObject so = new SerializedObject(m_model);
            WekaScoringModel copy = (WekaScoringModel) so.getObject();
            copy.setLog(getLog());
            retval.setModel(copy);
        } catch (Exception ex) {
            logError(BaseMessages.getString(PKG, "WekaScoringMeta.Log.DeepCopyingError")); //$NON-NLS-1$
        }
    }

    // deep copy the default model (if any)
    if (m_defaultModel != null) {
        try {
            SerializedObject so = new SerializedObject(m_defaultModel);
            WekaScoringModel copy = (WekaScoringModel) so.getObject();
            copy.setLog(getLog());
            retval.setDefaultModel(copy);
        } catch (Exception ex) {
            logError(BaseMessages.getString(PKG, "WekaScoringMeta.Log.DeepCopyingError")); //$NON-NLS-1$
        }
    }

    return retval;
}