示例#1
0
  public boolean predict(SingleDecision decision) throws MaltChainedException {
    if (getGuide().getGuideMode() == ClassifierGuide.GuideMode.BATCH) {
      throw new GuideException("Can only predict during parsing. ");
    } else if (!(divideFeature.getFeatureValue() instanceof SingleFeatureValue)) {
      throw new GuideException("The divide feature does not have a single value. ");
    }

    // divideFeature.update();
    if (divideModels != null
        && divideModels.containsKey(
            ((SingleFeatureValue) divideFeature.getFeatureValue()).getCode())) {
      return divideModels
          .get(((SingleFeatureValue) divideFeature.getFeatureValue()).getCode())
          .predict(decision);
    } else if (masterModel != null && masterModel.getFrequency() > 0) {
      return masterModel.predict(decision);
    } else {
      getGuide()
          .getConfiguration()
          .getConfigLogger()
          .info(
              "Could not predict the next parser decision because there is "
                  + "no divide or master model that covers the divide value '"
                  + ((SingleFeatureValue) divideFeature.getFeatureValue()).getCode()
                  + "', as default"
                  + " class code '1' is used. ");

      decision.addDecision(1); // default prediction
      // classCodeTable.getEmptyKBestList().addKBestItem(1);
    }
    return true;
  }
示例#2
0
  public void addInstance(SingleDecision decision, FeatureVector featureVector)
      throws MaltChainedException {
    if (featureVector == null) {
      throw new LibException("The feature vector cannot be found");
    } else if (decision == null) {
      throw new LibException("The decision cannot be found");
    }

    try {
      sb.append(decision.getDecisionCode() + "\t");
      final int n = featureVector.size();
      for (int i = 0; i < n; i++) {
        FeatureValue featureValue = featureVector.getFeatureValue(i);
        if (featureValue == null || (excludeNullValues == true && featureValue.isNullValue())) {
          sb.append("-1");
        } else {
          if (featureValue instanceof SingleFeatureValue) {
            SingleFeatureValue singleFeatureValue = (SingleFeatureValue) featureValue;
            if (singleFeatureValue.getValue() == 1) {
              sb.append(singleFeatureValue.getIndexCode());
            } else if (singleFeatureValue.getValue() == 0) {
              sb.append("-1");
            } else {
              sb.append(singleFeatureValue.getIndexCode());
              sb.append(":");
              sb.append(singleFeatureValue.getValue());
            }
          } else if (featureValue instanceof MultipleFeatureValue) {
            Set<Integer> values = ((MultipleFeatureValue) featureValue).getCodes();
            int j = 0;
            for (Integer value : values) {
              sb.append(value.toString());
              if (j != values.size() - 1) {
                sb.append("|");
              }
              j++;
            }
          } else {
            throw new LibException(
                "Don't recognize the type of feature value: " + featureValue.getClass());
          }
        }
        sb.append('\t');
      }
      sb.append('\n');
      instanceOutput.write(sb.toString());
      instanceOutput.flush();
      increaseNumberOfInstances();
      sb.setLength(0);
    } catch (IOException e) {
      throw new LibException("The learner cannot write to the instance file. ", e);
    }
  }
示例#3
0
 /**
  * Updates the corresponding single decision with the next value in the k-best list.
  *
  * @return true if decision has been updated, otherwise false
  * @throws MaltChainedException
  */
 public boolean updateActionWithNextKBest() throws MaltChainedException {
   if (addCandidateIndex != 0
       && topCandidateIndex < addCandidateIndex
       && topCandidateIndex < kBestList.size()) {
     int actionCode = kBestList.get(topCandidateIndex).getActionCode();
     if (decision instanceof SingleDecision) {
       ((SingleDecision) decision).addDecision(actionCode);
     }
     topCandidateIndex++;
     return true;
   }
   return false;
 }
示例#4
0
 /**
  * Adds a candidate to the k-best list
  *
  * @param actionCode the integer representation of candidate action
  * @throws MaltChainedException
  */
 public void add(int actionCode) throws MaltChainedException {
   if (k != -1 && addCandidateIndex >= k) {
     return;
   }
   if (addCandidateIndex >= kBestList.size()) {
     kBestList.add(new Candidate());
   }
   kBestList.get(addCandidateIndex).setActionCode(actionCode);
   if (addCandidateIndex == 0) {
     if (decision instanceof SingleDecision) {
       ((SingleDecision) decision).addDecision(actionCode);
     }
     topCandidateIndex++;
   }
   addCandidateIndex++;
 }
示例#5
0
  public boolean predict(FeatureVector featureVector, SingleDecision decision)
      throws MaltChainedException {
    if (featureVector == null) {
      throw new LibException(
          "The learner cannot predict the next class, because the feature vector cannot be found. ");
    }

    final FeatureList featureList = new FeatureList();
    final int size = featureVector.size();
    for (int i = 1; i <= size; i++) {
      final FeatureValue featureValue = featureVector.getFeatureValue(i - 1);
      if (featureValue != null && !(excludeNullValues == true && featureValue.isNullValue())) {
        if (featureValue instanceof SingleFeatureValue) {
          SingleFeatureValue singleFeatureValue = (SingleFeatureValue) featureValue;
          int index = featureMap.getIndex(i, singleFeatureValue.getIndexCode());
          if (index != -1 && singleFeatureValue.getValue() != 0) {
            featureList.add(index, singleFeatureValue.getValue());
          }
        } else if (featureValue instanceof MultipleFeatureValue) {
          for (Integer value : ((MultipleFeatureValue) featureValue).getCodes()) {
            int v = featureMap.getIndex(i, value);
            if (v != -1) {
              featureList.add(v, 1);
            }
          }
        }
      }
    }
    try {
      decision.getKBestList().addList(model.predict(featureList.toArray()));
      //			decision.getKBestList().addList(prediction(featureList));
    } catch (OutOfMemoryError e) {
      throw new LibException("Out of memory. Please increase the Java heap size (-Xmx<size>). ", e);
    }
    return true;
  }