@SuppressWarnings({"rawtypes", "unchecked"}) private ObjectNode writeValue(Value<?> value) { ObjectNode jValue; Class<?> valueType = value.value().getClass(); ValueTypeSerializer vts = valueTypeSerializerRegistry.getSerializer(valueType); if(vts != null){ jValue = vts.serialize(mapper,value.value()); //TODO assert that jValue does not define "class" and "prob"! } else { //use the default binding and the "data" field jValue = mapper.createObjectNode(); jValue.put("value", mapper.valueToTree(value.value())); } jValue.put("class",valueType.getName()); if(value.probability() != Value.UNKNOWN_PROBABILITY){ jValue.put("prob", value.probability()); } return jValue; } }
public static <T> Value<T> value(T value){ return new Value<T>(value); }
public static <T> List<Value<T>> values(T[] values, double[] probabilities){ return values(values,probabilities,values.length); } public static <T> List<Value<T>> values(T[] values, double[] probabilities,int elements){
private boolean isSectionBorder(Token token, String language) { Value<PosTag> posAnnotation = token.getAnnotation(NlpAnnotations.POS_ANNOTATION); if(posAnnotation != null && !Collections.disjoint(sectionBorderPosTags, posAnnotation.value().getPosHierarchy())){ return true; } else { return false; } }
process = true; Value<PosTag> posTag = token.getAnnotation(NlpAnnotations.POS_ANNOTATION); if(posTag != null && posTag.probability() == Value.UNKNOWN_PROBABILITY || posTag.probability() >= (minPOSConfidence/2.0)){ cats = classifier.getCategories(posTag.value()); } else { //no POS tags or probability to low cats = Collections.emptySet(); while(!ignore && !process && posTags.hasNext()) { Value<PosTag> value = posTags.next(); PosTag tag = value.value(); cats = classifier.getCategories(tag); boolean state = cats.contains(LexicalCategory.Adjective) || cats.contains(LexicalCategory.Noun); ignore = !state && (value.probability() == Value.UNKNOWN_PROBABILITY || value.probability() >= minPOSConfidence); process = state && (value.probability() == Value.UNKNOWN_PROBABILITY || value.probability() >= (minPOSConfidence/2.0)); token.addAnnotation(SENTIMENT_ANNOTATION, new Value<Double>(sentiment));
+ "does not provide POS tags for each token!"); } else { posList.add(posValue.value().getTag()); tokenList.get(i-1).getEnd()); chunk.addAnnotation(PHRASE_ANNOTATION, new Value<PhraseTag>(tag, chunkProps/(double)chunkTokenCount)); tokenList.get(i-1).getEnd()); chunk.addAnnotation(PHRASE_ANNOTATION, new Value<PhraseTag>(tag, chunkProps/(double)chunkTokenCount));
/** * Sets the {@link Nif20#oliaConf} value. Note this also deletes existing * values. This mans that in the case of multiple Olia annotation (e.g. * single word phrases together with word level annotation) the last * confidence will win (still better as having two confidence values) * @param graph * @param segmentUri * @param value */ private static void setOliaConf(Graph graph, IRI segmentUri, Value<?> value) { Iterator<Triple> existingConfValues = graph.filter(segmentUri, Nif20.oliaConf.getUri(), null); while(existingConfValues.hasNext()){ existingConfValues.next(); existingConfValues.remove(); } if(value.probability() != Value.UNKNOWN_PROBABILITY){ graph.add(new TripleImpl(segmentUri, Nif20.oliaConf.getUri(), lf.createTypedLiteral(value.probability()))); } }
private boolean isCoordinatingConjuction(Token token, String language) { Value<PosTag> posAnnotation = token.getAnnotation(NlpAnnotations.POS_ANNOTATION); return posAnnotation == null ? false : posAnnotation.value().getPosHierarchy().contains(Pos.CoordinatingConjunction); }
@SuppressWarnings({"rawtypes", "unchecked"}) private ObjectNode writeValue(Value<?> value) { ObjectNode jValue; Class<?> valueType = value.value().getClass(); ValueTypeSerializer vts = valueTypeSerializerRegistry.getSerializer(valueType); if(vts != null){ jValue = vts.serialize(mapper,value.value()); //TODO assert that jValue does not define "class" and "prob"! } else { //use the default binding and the "data" field jValue = mapper.createObjectNode(); jValue.put("value", mapper.valueToTree(value.value())); } jValue.put("class",valueType.getName()); if(value.probability() != Value.UNKNOWN_PROBABILITY){ jValue.put("prob", value.probability()); } return jValue; } }
private boolean isPronoun(Token token, String language) { Value<PosTag> posAnnotation = token.getAnnotation(NlpAnnotations.POS_ANNOTATION); return posAnnotation == null ? false : posAnnotation.value().getPosHierarchy().contains(Pos.Pronoun); }
public static <T> Value<T> value(T value,double probability){ return new Value<T>(value,probability); }
public static <T> List<Value<T>> values(T[] values, double[] probabilities){ return values(values,probabilities,values.length); } public static <T> List<Value<T>> values(T[] values, double[] probabilities,int elements){
Boolean process = null; for (Value<PhraseTag> phraseAnnotation : chunk.getAnnotations(PHRASE_ANNOTATION)) { if (tpc.getProcessedPhraseCategories().contains(phraseAnnotation.value().getCategory()) || tpc.getProcessedPhraseTags().contains(phraseAnnotation.value().getTag())) { if (phraseAnnotation.probability() == Value.UNKNOWN_PROBABILITY || phraseAnnotation.probability() >= tpc.getMinPhraseAnnotationProbability()) { process = true; break; } else if (phraseAnnotation.probability() == Value.UNKNOWN_PROBABILITY || phraseAnnotation.probability() >= tpc.getMinExcludePhraseAnnotationProbability()) { process = false; break;
/** * used for trace level logging of Tokens part of a chunk * @param token * @return */ private String logPosCategories(Token token){ List<Value<PosTag>> posTags = token.getAnnotations(POS_ANNOTATION); List<String> catNames = new ArrayList<String>(posTags.size()); for(Value<PosTag> tag : posTags){ Set<LexicalCategory> cats = tag.value().getCategories(); if(cats.size() > 1){ catNames.add(cats.toString()); } else if(!cats.isEmpty()){ catNames.add(cats.iterator().next().toString()); } else { catNames.add(tag.value().getTag()); } } return catNames.toString(); }
public static <T> Value<T> value(T value,double probability){ return new Value<T>(value,probability); }
/** * Validates a given object's String representation to match one of the provided * values. */ public class ValueValidator implements ConstraintValidator<Value, Object> { /** * String array of possible enum values */ private String[] values; @Override public void initialize(final Value constraintAnnotation) { this.values = constraintAnnotation.values(); } @Override public boolean isValid(final Object value, final ConstraintValidatorContext context) { return ArrayUtils.contains(this.values, value == null ? null : value.toString()); } }
for(Value<PosTag> pos : token.getAnnotations(POS_ANNOTATION)){ log.trace(" - {}",pos); double score = pos.probability(); if(score == Value.UNKNOWN_PROBABILITY){ score = DEFAULT_SCORE; if(ttd[i].matches(pos.value())){ log.trace(" matches Category {} with score {}",i,score); matchScores[i] = matchScores[i] + score;
/** * Checks if the parsed {@link Token} represents an negation * @param token the word * @param language the language * @return <code>true</code> if the {@link Token} represents a negation. * Otherwise <code>false</code> */ private boolean isNegation(Token token, String language) { Value<PosTag> posAnnotation = token.getAnnotation(NlpAnnotations.POS_ANNOTATION); if(posAnnotation != null && !Collections.disjoint(negativePosTags, posAnnotation.value().getPosHierarchy())){ return true; } else { return false; } }
public static <T> Value<T> value(T value){ return new Value<T>(value); }
token.addAnnotations(POS_ANNOTATION, Value.values(actPos, actProp,j));